lazycodex-ai 5.1.44 → 5.1.46

package/packages/omo-codex/plugin/skills/ulw-research/scripts/lexicon.mjs

@@ -0,0 +1,47 @@
+// Bilingual fidelity lexicon: data only, read by the fidelity checks and the meaning-pair router.
+// Korean entries are \u escapes (this directory ships no Hangul); each list is frozen.
+
+// Hedge tokens: a source hedge the report drops is hedge_dropped.
+export const HEDGES = Object.freeze([
+	...["estimated", "about", "approximately", "may", "might", "expected", "forecast", "provisional", "not yet"],
+	...["\uCD94\uC815", "\uC57D", "\uAC00\uB2A5", "\uC804\uB9DD", "\uC608\uC0C1", "\uC7A0\uC815", "\uC544\uC9C1", "\uBBF8\uD655\uC815", "\uAC83\uC73C\uB85C \uBCF4\uC778\uB2E4"],
+])
+
+// Closed qualifier list for the ledger qualifier field (bounding or approximation words).
+export const QUALIFIERS = Object.freeze([
+	...["up to", "at least", "at most", "about", "approximately", "nearly", "over", "under", "more than", "less than"],
+	...["\uCD5C\uB300", "\uCD5C\uC18C", "\uC57D", "\uC774\uC0C1", "\uC774\uD558", "\uBBF8\uB9CC", "\uCD08\uACFC", "\uB0B4\uC678", "\uAE4C\uC9C0"],
+])
+
+// Direction classes: a source in one class and an assertion in the other is direction_flipped.
+export const DIRECTION = Object.freeze({
+	up: Object.freeze([...["increase", "rise", "grow", "up"], ...["\uC99D\uAC00", "\uC0C1\uC2B9", "\uB298"]]),
+	down: Object.freeze([...["decrease", "fall", "decline", "down"], ...["\uAC10\uC18C", "\uD558\uB77D", "\uC904"]]),
+})
+
+// Causal connectives: one in the assertion but in no supporting quote is causality_added.
+export const CAUSAL = Object.freeze([
+	...["because", "due to", "leads to", "results in", "causes", "therefore"],
+	...["\uB54C\uBB38\uC5D0", "\uB85C \uC778\uD574", "\uB530\uB77C\uC11C", "\uADF8\uB798\uC11C", "\uCD08\uB798"],
+])
+
+// Concessive connectives for the hedge-position routing heuristic.
+export const CONCESSIVE = Object.freeze([
+	...["although", "but", "however", "despite", "while"],
+	...["\uC73C\uB098", "\uC9C0\uB9CC", "\uC5D0\uB3C4 \uBD88\uAD6C\uD558\uACE0", "\uBC18\uBA74", "\uC640 \uB2EC\uB9AC"],
+])
+
+// Narrow-to-broad scope pairs [narrow, broad] for scope_widened_warn.
+export const SCOPE_NARROW_TO_BROAD = Object.freeze([
+	Object.freeze(["\uBD81\uBBF8", "\uC804 \uC138\uACC4"]),
+	Object.freeze(["pilot", "system"]),
+	Object.freeze(["one region", "all regions"]),
+	Object.freeze(["\uC77C\uBD80", "\uC804\uCCB4"]),
+	Object.freeze(["\uD55C \uC9C0\uC5ED", "\uC804\uAD6D"]),
+])
+
+// Negation tokens; negated direction cases route to a reader instead of the lexicon.
+export const NEGATION = Object.freeze([
+	...["not", "no", "never"],
+	...["\uC54A", "\uC5C6", "\uBABB"],
+])

package/packages/omo-codex/plugin/skills/ulw-research/scripts/md-lite.mjs

@@ -0,0 +1,193 @@
+// md-lite.mjs - a light Markdown block model for md/post deliverables.
+//
+// parseMarkdown(text) returns { blocks } in document order, each block one of heading,
+// paragraph, list_item, table_row, code, blockquote, with start/end offsets into the raw text
+// so text.slice(start, end) === block.text (table cells carry their own offsets). Headings carry
+// level 1-6. Code blocks are fenced (``` or ~~~); an unterminated fence runs to the end of the
+// text and is reported in problems as unterminated_fence, which a caller must refuse rather than
+// skip. Callers skip kind 'code' when they look for numbers. sectionKindsMd(blocks) classifies
+// sections with the gates-static classifier itself (sectionKind, closingTest). It never renders
+// HTML. Plain Node ESM, sibling imports only.
+
+import { closingTest, sectionKind } from "./gates-static.mjs"
+
+export { closingTest, sectionKind }
+
+/** A fence opener: a backtick fence's info string holds no backtick (else it is an inline span). */
+const FENCE = /^ {0,3}(?:(`{3,})[^`]*|(~{3,}).*)$/
+const HEADING = /^ {0,3}(#{1,6})(?=[ \t]|$)/
+const BLOCKQUOTE = /^ {0,3}> ?/
+/** A bullet or an ordered marker (digits, then . or ), then a space); group 1 is the number. */
+const LIST_ITEM = /^[ \t]*(?:[-*+]|(\d{1,9})[.)])[ \t]+/
+const TABLE_SEPARATOR = /^[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/
+const CLOSING_HASHES = /[ \t]+#+[ \t]*$|^#+[ \t]*$/
+const THEMATIC_BREAK = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/
+
+/** The Markdown block grammar, one named pattern per syntax. */
+export const MD_BLOCK_PATTERNS = Object.freeze({ FENCE, HEADING, BLOCKQUOTE, LIST_ITEM, TABLE_SEPARATOR, CLOSING_HASHES, THEMATIC_BREAK })
+
+/** Split into lines with offsets; end excludes the newline and a trailing carriage return. */
+function linesOf(text) {
+	const lines = []
+	let start = 0
+	while (start <= text.length) {
+		const newline = text.indexOf("\n", start)
+		const next = newline === -1 ? text.length + 1 : newline + 1
+		let end = newline === -1 ? text.length : newline
+		if (end > start && text[end - 1] === "\r") end--
+		lines.push({ start, end, next, raw: text.slice(start, end) })
+		start = next
+	}
+	return lines
+}
+
+/** Narrow [start, end) to its non-whitespace core. */
+function trimRange(text, start, end) {
+	let from = start
+	let to = end
+	while (from < to && /\s/.test(text[from])) from++
+	while (to > from && /\s/.test(text[to - 1])) to--
+	return { start: from, end: to }
+}
+
+function block(text, kind, range, extra = {}) {
+	return { kind, ...extra, text: text.slice(range.start, range.end), start: range.start, end: range.end }
+}
+
+function isSeparator(line) {
+	return line !== undefined && line.raw.includes("-") && TABLE_SEPARATOR.test(line.raw)
+}
+
+/** Cells split on unescaped pipes, outer pipes dropped, each cell trimmed with offsets. */
+function tableCells(text, range) {
+	const bounds = []
+	for (let k = range.start; k < range.end; k++) {
+		let slashes = 0
+		while (k - slashes - 1 >= range.start && text[k - slashes - 1] === "\\") slashes++
+		if (text[k] === "|" && slashes % 2 === 0) bounds.push(k)
+	}
+	const edges = [range.start - 1, ...bounds, range.end]
+	if (bounds[0] === range.start) edges.shift()
+	if (bounds.at(-1) === range.end - 1 && bounds.length > 0) edges.pop()
+	const cells = []
+	for (let k = 0; k + 1 < edges.length; k++) {
+		const cell = trimRange(text, edges[k] + 1, edges[k + 1])
+		cells.push({ text: text.slice(cell.start, cell.end), start: cell.start, end: cell.end })
+	}
+	return cells
+}
+
+function headingBlock(text, line, marker) {
+	const after = line.start + line.raw.indexOf(marker) + marker.length
+	const range = trimRange(text, after, line.end)
+	const closing = text.slice(range.start, range.end).match(CLOSING_HASHES)
+	if (closing) range.end = trimRange(text, range.start, range.start + (closing.index ?? 0)).end
+	return block(text, "heading", range, { level: marker.length })
+}
+
+/**
+ * Parse Markdown into a flat block list.
+ * @param {string} text
+ * @returns {{ blocks: { kind: string, level?: number, text: string, start: number, end: number,
+ *   cells?: { text: string, start: number, end: number }[] }[],
+ *   problems: { code: "unterminated_fence", line: number, start: number }[] }}
+ */
+export function parseMarkdown(text) {
+	const source = String(text ?? "")
+	const lines = linesOf(source)
+	const blocks = []
+	const problems = []
+	let paragraph = null
+	let inTable = false
+	const flush = () => {
+		if (paragraph) blocks.push(block(source, "paragraph", paragraph))
+		paragraph = null
+	}
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]
+		const fence = line.raw.match(FENCE)
+		if (fence) {
+			flush()
+			inTable = false
+			const open = fence[1] ?? fence[2]
+			const codeStart = Math.min(line.next, source.length)
+			let close = lines.length
+			for (let k = i + 1; k < lines.length; k++) {
+				const candidate = lines[k].raw.trim()
+				if (candidate.startsWith(open[0].repeat(open.length)) && /^(`+|~+)$/.test(candidate)) {
+					close = k
+					break
+				}
+			}
+			let codeEnd = source.length
+			if (close === lines.length) problems.push({ code: "unterminated_fence", line: i + 1, start: line.start })
+			else {
+				codeEnd = Math.max(codeStart, lines[close].start - 1)
+				if (codeEnd > codeStart && source[codeEnd - 1] === "\r") codeEnd--
+			}
+			blocks.push(block(source, "code", { start: codeStart, end: codeEnd }))
+			i = close
+			continue
+		}
+		if (line.raw.trim() === "") {
+			flush()
+			inTable = false
+			continue
+		}
+		const range = trimRange(source, line.start, line.end)
+		if (!inTable && line.raw.includes("|") && isSeparator(lines[i + 1])) inTable = true
+		if (inTable && line.raw.includes("|")) {
+			flush()
+			if (!isSeparator(line)) blocks.push(block(source, "table_row", range, { cells: tableCells(source, range) }))
+			continue
+		}
+		inTable = false
+		const heading = line.raw.match(HEADING)
+		if (heading) {
+			flush()
+			blocks.push(headingBlock(source, line, heading[1]))
+			continue
+		}
+		if (THEMATIC_BREAK.test(line.raw)) {
+			flush()
+			continue
+		}
+		const marker = line.raw.match(BLOCKQUOTE) ?? line.raw.match(LIST_ITEM)
+		// Only an ordered marker numbered 1 may interrupt a paragraph (CommonMark); else it is text.
+		const continues = paragraph !== null && marker?.[1] !== undefined && Number(marker[1]) !== 1
+		if (marker && !continues) {
+			flush()
+			const kind = BLOCKQUOTE.test(line.raw) ? "blockquote" : "list_item"
+			const content = trimRange(source, line.start + marker[0].length, line.end)
+			if (content.end > content.start) blocks.push(block(source, kind, content))
+			continue
+		}
+		if (paragraph) paragraph.end = range.end
+		else paragraph = { start: range.start, end: range.end }
+	}
+	flush()
+	return { blocks, problems }
+}
+
+/**
+ * Section kind of every block, parallel to blocks: an h2 opens a section whose kind comes from
+ * its heading text (sources, closing, toc, appendix, glossary, or null for findings); an h3 that
+ * reads as a closing heading marks its blocks closing until the next h2 or h3, as in gates-static.
+ * @param {{ kind: string, level?: number, text: string }[]} blocks
+ * @param {{ closingPattern?: RegExp|string }} [options] extra closing heading pattern (the spec's)
+ * @returns {(string|null)[]}
+ */
+export function sectionKindsMd(blocks, options = {}) {
+	const isClosing = closingTest(options.closingPattern)
+	let section = null
+	let closingH3 = false
+	return blocks.map((entry) => {
+		if (entry.kind === "heading" && entry.level === 2) {
+			section = sectionKind(entry.text, isClosing)
+			closingH3 = false
+		} else if (entry.kind === "heading" && entry.level === 3) {
+			closingH3 = isClosing(entry.text)
+		}
+		return closingH3 ? "closing" : section
+	})
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/meaning-check.mjs

@@ -0,0 +1,196 @@
+// meaning-check.mjs - ingest the meaning readers' verdicts over fact-pairs output.
+//
+// ingestVerdicts reads verdict files written by separate reader lanes (cheap and strong tiers),
+// keeps a drift verdict only when its pair exists, its tier and drift_kind are in the closed sets,
+// and both its fragment (from the sentence) and source_fragment (from the quote or statement) are
+// non-empty substrings after whitespace normalization; every other verdict is dropped and logged.
+// Both tiers naming the same drift_kind (not "other") on a pair is meaning_drift_confirmed (major,
+// never integrity); one tier is meaning_drift_warn (minor). Each flagged pair yields one
+// calibration line; a dispute is recorded there and never removes the defect. Coverage is
+// fail-closed: every pair no reader judged, and every force_strong pair no strong reader judged,
+// is listed in `unverified`, so a gate can tell a clean check apart from a pair nobody read.
+// No model, no fetch.
+
+import { appendFileSync, readFileSync } from "node:fs"
+
+import { DEFECT_CODES } from "./contracts.mjs"
+
+export const DRIFT_KINDS = Object.freeze([
+	"subject_changed", "scope_widened", "hedge_dropped", "certainty_added", "causality_added",
+	"direction_flipped", "population_changed", "evidence_grade_raised", "other",
+])
+export const MODEL_TIERS = Object.freeze(["cheap", "strong"])
+export const VERDICTS = Object.freeze(["drift", "ok"])
+export const isDriftKind = (kind) => DRIFT_KINDS.includes(kind)
+/** The machine-read verdict contract a reader lane receives with pairs.json; built from the registries above. */
+export const VERDICT_SCHEMA = Object.freeze({
+	model_tier: MODEL_TIERS,
+	verdict: VERDICTS,
+	drift_kind: DRIFT_KINDS,
+	required: Object.freeze(["pair_id", "verdict"]),
+	drift_required: Object.freeze(["drift_kind", "fragment", "source_fragment"]),
+})
+
+/** NFC, every whitespace run collapsed to one space, trimmed. */
+const squash = (text) => String(text ?? "").normalize("NFC").replace(/\s+/gu, " ").trim()
+
+/** Read a verdict file, mapping an unreadable path or invalid JSON to a short typed error. */
+function parseFile(path) {
+	let text
+	try {
+		text = readFileSync(path, "utf8")
+	} catch {
+		throw new TypeError(`${path}: cannot read the verdict file`)
+	}
+	try {
+		return JSON.parse(text)
+	} catch {
+		throw new TypeError(`${path}: the verdict file is not valid JSON`)
+	}
+}
+
+function verdictsOf(input) {
+	const label = typeof input === "string" ? input : "<inline>"
+	const parsed = typeof input === "string" ? parseFile(input) : input
+	const list = Array.isArray(parsed) ? parsed : parsed?.verdicts
+	if (!Array.isArray(list)) throw new TypeError(`${label}: a verdict file is an array of verdicts or { verdicts: [...] }`)
+	const tier = Array.isArray(parsed) ? undefined : parsed.model_tier
+	return list.map((verdict) => ({ verdict: tier === undefined || verdict?.model_tier !== undefined ? verdict : { ...verdict, model_tier: tier }, file: label }))
+}
+
+/** The reason a verdict is dropped, or null when it is accepted. */
+function dropReason(verdict, pair) {
+	if (verdict === null || typeof verdict !== "object") return "malformed_verdict"
+	if (!pair) return "unknown_pair"
+	if (!VERDICTS.includes(verdict.verdict)) return "invalid_verdict"
+	if (!MODEL_TIERS.includes(verdict.model_tier)) return "invalid_model_tier"
+	if (verdict.verdict === "ok") return null
+	if (!isDriftKind(verdict.drift_kind)) return "unknown_drift_kind"
+	const [fragment, sourceFragment] = [squash(verdict.fragment), squash(verdict.source_fragment)]
+	if (fragment === "" || sourceFragment === "") return "empty_fragment"
+	if (!squash(pair.sentence).includes(fragment)) return "fragment_not_found"
+	const source = pair.kind === "claim" ? pair.statement : pair.quote
+	if (!squash(source).includes(sourceFragment)) return "source_fragment_not_found"
+	return null
+}
+
+function defect(code, pair, driftKind, tiers, verdicts) {
+	const entry = DEFECT_CODES[code]
+	// The fragment must come from the verdict whose drift_kind is being reported, not from whichever
+	// verdict happened to arrive first on the pair.
+	const first = verdicts.find((verdict) => verdict.drift_kind === driftKind) ?? verdicts[0]
+	return {
+		code,
+		severity: entry.severity,
+		integrity: entry.integrity,
+		pair_id: pair.pair_id,
+		sentence_key: pair.sentence_key ?? null,
+		drift_kind: driftKind,
+		tiers,
+		fragment: first.fragment,
+		source_fragment: first.source_fragment,
+		selector: null,
+		line: null,
+		message: `${pair.pair_id}: ${tiers.join(" and ")} reader${tiers.length > 1 ? "s" : ""} found ${driftKind} at "${squash(first.fragment)}"`,
+		hint: entry.hint,
+	}
+}
+
+/** One meaning_unverified defect per coverage gap, so blocksDelivery sees an unread pair through the registry. */
+export function unverifiedDefects(unverified) {
+	const entry = DEFECT_CODES.meaning_unverified
+	return unverified.map((gap) => ({
+		code: "meaning_unverified",
+		severity: entry.severity,
+		integrity: entry.integrity,
+		pair_id: gap.pair_id,
+		reason: gap.reason,
+		selector: null,
+		line: null,
+		message: `${gap.pair_id}: ${gap.reason === "no_strong_verdict" ? "no strong reader judged this force_strong pair" : "no reader judged this pair"}`,
+		hint: entry.hint,
+	}))
+}
+
+/** Pairs with no accepted verdict, and force_strong pairs with no accepted strong verdict, in pair order. */
+function coverageGaps(list, accepted) {
+	const tiersByPair = new Map()
+	for (const verdict of accepted) {
+		tiersByPair.set(verdict.pair_id, (tiersByPair.get(verdict.pair_id) ?? new Set()).add(verdict.model_tier))
+	}
+	const gaps = []
+	for (const pair of list) {
+		const tiers = tiersByPair.get(pair.pair_id)
+		if (tiers === undefined || tiers.size === 0) gaps.push({ pair_id: pair.pair_id, reason: "no_verdict" })
+		else if (pair.force_strong === true && !tiers.has("strong")) gaps.push({ pair_id: pair.pair_id, reason: "no_strong_verdict" })
+	}
+	return gaps
+}
+
+/** Group accepted drift verdicts per pair, then per tier. */
+function flaggedPairs(accepted) {
+	const byPair = new Map()
+	for (const verdict of accepted) {
+		if (verdict.verdict !== "drift") continue
+		const tiers = byPair.get(verdict.pair_id) ?? new Map()
+		tiers.set(verdict.model_tier, [...(tiers.get(verdict.model_tier) ?? []), verdict])
+		byPair.set(verdict.pair_id, tiers)
+	}
+	return byPair
+}
+
+/** The drift_kind both tiers named (never "other"), or null. */
+function agreedKind(tiers) {
+	const [cheap, strong] = MODEL_TIERS.map((tier) => tiers.get(tier) ?? [])
+	return cheap.map((verdict) => verdict.drift_kind).find((kind) => kind !== "other" && strong.some((verdict) => verdict.drift_kind === kind)) ?? null
+}
+
+/**
+ * @param {object[] | { pairs: object[] }} pairs extractPairs(...) output
+ * @param {(string | object[] | { verdicts: object[], model_tier?: string })[]} verdictFiles paths, or parsed verdict lists
+ * @param {{ dispute?: { pair_id: string, reason: string }, calibrationPath?: string }} [options]
+ *   calibrationPath: append each calibration line to this JSONL file (fidelity-calibration.jsonl)
+ * @returns {{ defects: object[], dropped: object[], unverified: { pair_id: string, reason: string }[], calibrationLines: string[] }}
+ *   unverified lists, in pair order, every pair no reader judged (`no_verdict`) and every
+ *   force_strong pair no strong reader judged (`no_strong_verdict`); a verdict that was dropped
+ *   does not count as read. A consumer MUST treat a non-empty list as blocking: the pairs were
+ *   never checked, so an empty `defects` list does not mean the report is clean.
+ * @throws {TypeError} when pairs is neither an array nor `{ pairs: [...] }` (fail closed: a missing
+ *   pairs input never reads as a fully verified report)
+ */
+export function ingestVerdicts(pairs, verdictFiles, options = {}) {
+	const list = Array.isArray(pairs) ? pairs : pairs?.pairs
+	if (!Array.isArray(list)) throw new TypeError("pairs: expected an array of pairs or { pairs: [...] }")
+	const byId = new Map(list.map((pair) => [pair.pair_id, pair]))
+	const accepted = []
+	const dropped = []
+	for (const input of verdictFiles) {
+		for (const { verdict, file } of verdictsOf(input)) {
+			const reason = dropReason(verdict, byId.get(verdict?.pair_id))
+			if (reason === null) accepted.push(verdict)
+			else dropped.push({ file, pair_id: verdict?.pair_id ?? null, model_tier: verdict?.model_tier ?? null, reason })
+		}
+	}
+	const dispute = options.dispute ?? null
+	const defects = []
+	const calibrationLines = []
+	const flagged = flaggedPairs(accepted)
+	for (const pair of list) {
+		const tiers = flagged.get(pair.pair_id)
+		if (!tiers) continue
+		const tierNames = MODEL_TIERS.filter((tier) => tiers.has(tier))
+		const agreed = agreedKind(tiers)
+		const verdicts = MODEL_TIERS.flatMap((tier) => tiers.get(tier) ?? [])
+		const kind = agreed ?? verdicts[0].drift_kind
+		const confirmed = agreed !== null
+		defects.push(defect(confirmed ? "meaning_drift_confirmed" : "meaning_drift_warn", pair, kind, tierNames, verdicts))
+		const disputed = dispute !== null && dispute.pair_id === pair.pair_id
+		calibrationLines.push(JSON.stringify({ kind: pair.kind, pair_id: pair.pair_id, tiers: tierNames, drift_kind: kind, confirmed, disputed, reason: disputed ? String(dispute.reason ?? "") : null }))
+	}
+	const unverified = coverageGaps(list, accepted)
+	if (dispute !== null && !flagged.has(dispute.pair_id)) {
+		dropped.push({ file: "<dispute>", pair_id: dispute.pair_id, model_tier: null, reason: "dispute_not_flagged" })
+	}
+	if (options.calibrationPath && calibrationLines.length > 0) appendFileSync(options.calibrationPath, `${calibrationLines.join("\n")}\n`)
+	return { defects, dropped, unverified, calibrationLines }
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/numerals.mjs

@@ -0,0 +1,226 @@
+// numerals.mjs - shared numeral patterns and the numeral parser.
+//
+// NUM, UNIT, NOT_CLAIMS and CLAIMS are the claim-detection patterns the unsourced-number gate uses
+// (gates-text.mjs imports them from here). parseNumeral reads one numeral into an exact decimal
+// string: thousands separators, Korean and Latin scale words, percent and percentage points, the
+// English number words one to twelve, an adjacent currency symbol or unit, and an adjacent bounding
+// qualifier. No numeral is ever passed through Number(). Plain Node ESM, sibling imports only.
+
+import { add, fromDecimal, mul, toDecimal } from "./rational.mjs"
+import { normalizeUnit } from "./units.mjs"
+
+const MONTH = "(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\\.?"
+/** Stripped before claim detection: dates, versions, figure refs, times, bare years. */
+export const NOT_CLAIMS = [
+	/\b\d{4}[-./]\d{1,2}(?:[-./]\d{1,2})?\b/g,
+	/\b\d{2}\.\d{2}\.\d{2}\b/g,
+	/\d{2,4}\s*\uB144\s*\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
+	/\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
+	/(?:19|20)\d{2}\s*\uB144/g,
+	new RegExp(`\\b${MONTH}\\s+\\d{1,2}(?:st|nd|rd|th)?(?:,?\\s+\\d{4})?`, "gi"),
+	new RegExp(`\\b\\d{1,2}(?:st|nd|rd|th)?\\s+${MONTH}(?:\\s+\\d{4})?`, "gi"),
+	/\bv\d+(?:\.\d+)*\b|\b\d+(?:\.\d+){2,}\b/gi,
+	/\b(?:version|ver\.?|release)\s*\d+(?:\.\d+)*/gi,
+	/\b(?:fig(?:ure)?\.?|table|chart|section|step|phase|wave|part)\s*\d+(?:\.\d+)*/gi,
+	/(?:\uADF8\uB9BC|\uB3C4\uD45C|\uD45C|\uBC84\uC804)\s*\d+(?:\.\d+)*/g,
+	/\b\d{1,2}:\d{2}\b/g,
+	/\b(?:19|20)\d{2}s?\b/g,
+]
+export const NUM = "(?<![\\p{L}\\d.,])\\d+(?:[.,]\\d+)*"
+export const UNIT =
+	"(?:%|\\u2030|\\u00D7|\\uD37C\\uC13C\\uD2B8|\\uB2EC\\uB7EC|\\uC720\\uB85C|\\uC5D4|\\uC6D0|\\uB9CC|\\uC5B5|\\uC870|\\uCC9C|\\uCD08|\\uBD84|\\uC2DC\\uAC04|\\uC77C|\\uC8FC|\\uAC1C\\uC6D4|\\uB144|\\uBA85|\\uAC74|\\uAC1C|\\uD68C|\\uBC88|\\uBC30" +
+	"|(?:percent|pp|bps?|x|k|m|b|bn|million|billion|thousand|trillion|usd|krw|eur|ms|s|secs?|seconds?|mins?|minutes?|h|hrs?|hours?|days?|weeks?|months?|years?|kb|mb|gb|tb|users?|people|employees|engineers|tokens?|requests?|stars?|downloads?|customers?)(?![\\p{L}\\d]))"
+export const CLAIMS = [
+	new RegExp(`[$\\u20AC\\u00A3\\u00A5\\u20A9]\\s?${NUM}`, "u"),
+	new RegExp(`${NUM}\\s?${UNIT}`, "iu"),
+	/(?<![\d.,])\d{1,3}(?:,\d{3})+(?![\d,])/,
+	/(?<![\d.])\d+\.\d+(?![\d.])/,
+]
+
+const WORDS = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve"]
+const WORD_RE = new RegExp(`\\b(?:${WORDS.join("|")})\\b`, "gi")
+/** Korean scale words: cheon (1e3) inside a group, then man, eok, jo as group scales. */
+const CHEON = "\uCC9C"
+const BIG = new Map([["\uB9CC", 10000n], ["\uC5B5", 100000000n], ["\uC870", 1000000000000n]])
+/** A scale word that starts a longer word is not a scale: jogak (pieces), mankeum (as much as). */
+const KO_GROUP = /^(\s?)(?:(\uCC9C)?([\uB9CC\uC5B5\uC870])|(\uCC9C))(?![\uAC01\uD07C])/
+const KO_NEXT = new RegExp(`^\\s?(${NUM})(\uCC9C)?([\uB9CC\uC5B5\uC870])?`, "u")
+const LATIN_SCALE = /^(?:(k|K|M|bn|B)|\s(thousand|million|billion|trillion|bn))(?![\p{L}\d])/u
+const LATIN_FACTOR = { k: 1000n, K: 1000n, M: 1000000n, bn: 1000000000n, B: 1000000000n, thousand: 1000n, million: 1000000n, billion: 1000000000n, trillion: 1000000000000n }
+const CURRENCY = "$\u20AC\u00A3\u00A5\u20A9"
+const SYMBOL_UNIT = /^\s?(%p|%|\u2030|\u00D7|\u00B0C|\u00B0F|\u2103|\u2109)/
+const LATIN_UNIT = /^\s?([A-Za-z]+)(?![\p{L}\d])/u
+const HANGUL_UNIT = /^\s?([\uAC00-\uD7A3]+)/
+/** "3 bun-ui 1" is the fraction one third, not 3 minutes. */
+const FRACTION = /^\s?\uBD84\uC758\s?\d/
+const UNIT_AFTER = new RegExp(`^\\s?${UNIT}`, "iu")
+const NUM_AT = new RegExp(`^${NUM}`, "u")
+/** Range separators: hyphen, en dash, tilde, "to". */
+const RANGE_SEP = /^(?:\s?[-\u2013~]\s?|\sto\s)/
+const SIGN = "-\u2212"
+/** Bounding qualifiers: before the value (Korean and English) and right after it (Korean). */
+const QUALIFIERS_BEFORE = ["up to", "at least", "at most", "more than", "less than", "about", "approximately", "nearly", "over", "under", "\uCD5C\uB300", "\uCD5C\uC18C", "\uC57D"]
+const QUALIFIER_AFTER = /^\s?(\uC774\uC0C1|\uC774\uD558|\uBBF8\uB9CC|\uCD08\uACFC|\uB0B4\uC678|\uAE4C\uC9C0)/
+
+/** "1,237" -> "1237"; a malformed group ("1,23") keeps only the leading plain number. */
+function cleanDigits(raw) {
+	if (/^\d{1,3}(?:,\d{3})+(?:\.\d+)?$/.test(raw)) return { digits: raw.replace(/,/g, ""), length: raw.length }
+	const plain = /^\d+(?:\.\d+)?/.exec(raw)[0]
+	return { digits: plain, length: plain.length }
+}
+
+/** The bare-year and four-digit-date patterns: a numeral they cover can still be a value. */
+const YEAR_SHAPED = new Set([NOT_CLAIMS[0], NOT_CLAIMS[12]])
+
+function excludedRanges(text) {
+	const ranges = []
+	for (const re of NOT_CLAIMS) {
+		for (const match of text.matchAll(re)) ranges.push([match.index, match.index + match[0].length, YEAR_SHAPED.has(re)])
+	}
+	return ranges
+}
+
+/** A year-shaped numeral is a value when it has a decimal part or a currency, scale word or unit touches it. */
+function anchored(text, at, end, digits) {
+	if (digits.includes(".") || (at > 0 && CURRENCY.includes(text[at - 1]))) return true
+	return UNIT_AFTER.test(text.slice(end)) || unitAfter(text, end) !== null
+}
+
+/**
+ * First digit run or number word at or after `from` that no NOT_CLAIMS pattern covers. A year-shaped
+ * match exactly over the numeral (not "2020s", not "2020-03") is lifted when the numeral is anchored.
+ */
+function findStart(text, from, ranges) {
+	const covering = (at) => ranges.filter(([s, e]) => at >= s && at < e)
+	let digit = null
+	for (const match of text.slice(from).matchAll(new RegExp(NUM, "gu"))) {
+		const at = from + match.index
+		const candidate = { at, ...cleanDigits(match[0]) }
+		const end = at + candidate.length
+		const cover = covering(at)
+		const lifted = cover.every(([s, e, yearShaped]) => yearShaped && s === at && e <= end)
+		if (cover.length === 0 || (lifted && anchored(text, at, end, candidate.digits))) {
+			digit = candidate
+			break
+		}
+	}
+	const free = (at) => covering(at).length === 0
+	for (const match of text.slice(from).matchAll(WORD_RE)) {
+		const at = from + match.index
+		if (digit && digit.at < at) break
+		if (free(at)) return { at, digits: String(WORDS.indexOf(match[0].toLowerCase()) + 1), length: match[0].length }
+	}
+	return digit
+}
+
+/** Korean groups such as "4jo 2,000eok": each later group needs a smaller scale. */
+function koreanScale(text, at, digits) {
+	const first = KO_GROUP.exec(text.slice(at))
+	if (!first) return null
+	const big = first[3] ? BIG.get(first[3]) : 1n
+	const firstFactor = (first[2] || first[4] ? 1000n : 1n) * big
+	let value = mul(fromDecimal(digits), firstFactor)
+	let end = at + first[0].length
+	let last = first[3] ? big : 0n
+	let groups = 1
+	while (last > 1n) {
+		const next = KO_NEXT.exec(text.slice(end))
+		if (!next) break
+		const factor = (next[2] ? 1000n : 1n) * (next[3] ? BIG.get(next[3]) : 1n)
+		if (factor <= 1n || factor >= last) break
+		value = add(value, mul(fromDecimal(cleanDigits(next[1]).digits), factor))
+		end += next[0].length
+		last = next[3] ? BIG.get(next[3]) : 0n
+		groups++
+	}
+	return { value, end, factor: groups === 1 ? firstFactor : null }
+}
+
+/** Scale words after a numeral: { value (rational) | null, end, factor | null (one plain factor) }. */
+function scaled(text, end, digits) {
+	const korean = koreanScale(text, end, digits)
+	if (korean) return korean
+	const latin = LATIN_SCALE.exec(text.slice(end))
+	if (!latin) return { value: null, end, factor: null }
+	const factor = LATIN_FACTOR[latin[1] ?? latin[2].toLowerCase()]
+	return { value: mul(fromDecimal(digits), factor), end: end + latin[0].length, factor }
+}
+
+/** The second endpoint of "5-10", "5 to 10", "5~10" or "5\u201310", or null. */
+function rangeEnd(text, at, ranges) {
+	const sep = RANGE_SEP.exec(text.slice(at))
+	if (!sep) return null
+	const pos = at + sep[0].length
+	const num = NUM_AT.exec(text.slice(pos))
+	if (!num || ranges.some(([s, e]) => pos >= s && pos < e)) return null
+	const { digits, length } = cleanDigits(num[0])
+	const scale = scaled(text, pos + length, digits)
+	return { value: scale.value ? toDecimal(scale.value) : digits, end: scale.end, factor: scale.factor }
+}
+
+function unitAfter(text, at) {
+	const rest = text.slice(at)
+	if (FRACTION.test(rest)) return null
+	const symbol = SYMBOL_UNIT.exec(rest)
+	if (symbol) return { unitRaw: symbol[1], end: at + symbol[0].length }
+	const latin = LATIN_UNIT.exec(rest)
+	if (latin) return normalizeUnit(latin[1]) ? { unitRaw: latin[1], end: at + latin[0].length } : null
+	const hangul = HANGUL_UNIT.exec(rest)
+	if (!hangul) return null
+	const lead = hangul[0].length - hangul[1].length
+	for (let size = hangul[1].length; size > 0; size--) {
+		const candidate = hangul[1].slice(0, size)
+		if (!BIG.has(candidate) && candidate !== CHEON && normalizeUnit(candidate)) return { unitRaw: candidate, end: at + lead + size }
+	}
+	return null
+}
+
+function qualifierBefore(text, at) {
+	const tokens = text.slice(0, at).trim().split(/\s+/).slice(-2).map((token) => token.replace(/^[^\p{L}]+/u, ""))
+	for (const phrase of QUALIFIERS_BEFORE) {
+		const words = phrase.split(" ")
+		for (let skip = 0; skip + words.length <= tokens.length; skip++) {
+			const window = tokens.slice(tokens.length - skip - words.length, tokens.length - skip)
+			if (window.join(" ").toLowerCase() === phrase) return window.join(" ")
+		}
+	}
+	return null
+}
+
+/**
+ * The first numeral at or after `from`: { value, raw, span: [start, end], unitRaw, qualifierRaw },
+ * or null. `value` is an exact decimal string with scale words folded in ("3eok won" -> "300000000",
+ * unit "won") and a leading minus sign ("-" or U+2212) kept as "-"; `span` covers the sign, an
+ * adjacent currency symbol, the numeral, scale words and the unit. A range ("5-10 m", "5 to 10 m",
+ * "5~10%") adds `valueEnd` and `range: true`; the unit, and a scale word written only on the second
+ * endpoint ("3~5eok"), apply to both endpoints.
+ */
+export function parseNumeral(text, from = 0) {
+	const ranges = excludedRanges(text)
+	const found = findStart(text, from, ranges)
+	if (!found) return null
+	let start = found.at
+	const first = scaled(text, found.at + found.length, found.digits)
+	let value = first.value
+	let end = first.end
+	const second = rangeEnd(text, end, ranges)
+	if (second) {
+		end = second.end
+		if (!value && second.factor) value = mul(fromDecimal(found.digits), second.factor)
+	}
+	let unitRaw = null
+	if (start > 0 && CURRENCY.includes(text[start - 1])) [unitRaw, start] = [text[start - 1], start - 1]
+	const negative = start > 0 && SIGN.includes(text[start - 1]) && !/[\p{L}\p{N}]/u.test(text[start - 2] ?? "")
+	if (negative) start--
+	const unit = unitRaw ? null : unitAfter(text, end)
+	if (unit) [unitRaw, end] = [unit.unitRaw, unit.end]
+	const after = QUALIFIER_AFTER.exec(text.slice(end))
+	return {
+		value: (negative ? "-" : "") + (value ? toDecimal(value) : found.digits),
+		...(second ? { valueEnd: second.value, range: true } : {}),
+		raw: text.slice(start, end),
+		span: [start, end],
+		unitRaw,
+		qualifierRaw: qualifierBefore(text, start) ?? (after ? after[1] : null),
+	}
+}