oh-my-opencode 5.1.48 → 5.1.54

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-records.mjs

@@ -15,7 +15,7 @@
 // fidelity record exists, the barrier refuses the unverified edition regardless of it, and the same
 // exemption is the only way a required record may be absent.
 
-import { existsSync, readFileSync } from "node:fs"
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs"
 import { join } from "node:path"
 
 import { CliError, readJsonFile, sha256Of, writeJsonAtomic } from "./cli-support.mjs"
@@ -24,7 +24,10 @@ import { meaningCheckEnabled, requireLockedBrief } from "./fidelity-brief.mjs"
 import { blocksDelivery, deliveryBlockReason } from "./gates-fidelity.mjs"
 
 export const FIDELITY_RECORD = "fidelity-defects.json"
+/** The legacy session meaning record: a candidate for every edition whose bytes it claims, like any edition record (newest run wins). */
 export const MEANING_RECORD = "fidelity-meaning-defects.json"
+/** The meaning record of one delivered edition, named by its outcome format (`fact meaning-check --edition`). */
+export const meaningRecordName = (format) => `fidelity-meaning-defects.${format}.json`
 
 /** The fields every fidelity record carries, whatever its kind. */
 export const RECORD_ENVELOPE = Object.freeze(["record_kind", "artifact_sha256", "report", "written_at", "defects"])
@@ -39,13 +42,67 @@ function meaningRequired({ sessionDir }) {
 }
 
 const subjectOf = (row) => row.renderedFrom ?? row.path ?? null
+const hashOf = (path) => (existsSync(path) ? sha256Of(readFileSync(path)) : null)
 
 /** One record per delivered edition: the file its row names with --verified-by, bound to that edition's bytes. */
 const perEdition = (sessionDir, delivered) =>
 	delivered.map((row) => ({ path: row.verifiedBy ?? null, declared: row.verifiedBy !== undefined, format: row.format, at: `${row.format}: `, subjects: [subjectOf(row)].filter((subject) => subject !== null) }))
 
-/** One record per session, in the session directory, bound to any delivered edition's bytes. */
-const perSession = (file) => (sessionDir, delivered) => [{ path: join(sessionDir, file), declared: false, format: null, at: "", subjects: delivered.map(subjectOf).filter((subject) => subject !== null) }]
+const sessionTarget = (sessionDir, file) => ({ path: join(sessionDir, file), declared: false, format: null, at: "", subjects: [] })
+
+/** Include every existing session fidelity record, even when no delivered row attaches it. */
+const perEditionAndSession = (sessionDir, delivered) => [
+	...perEdition(sessionDir, delivered),
+	...(existsSync(join(sessionDir, FIDELITY_RECORD)) ? [sessionTarget(sessionDir, FIDELITY_RECORD)] : []),
+]
+
+/** Edition meaning records on disk (fidelity-meaning-defects.<format>.json). */
+const EDITION_MEANING = /^fidelity-meaning-defects\.[^.]+\.json$/u
+
+/** Verdict severity for equal times: a confirmed drift, then any other blocking defect (unverified), then clean. */
+const severityOf = (defects) =>
+	defects.some((defect) => defect?.code === "meaning_drift_confirmed") ? 2 : defects.some((defect) => typeof defect?.code === "string" && blocksDelivery(defect)) ? 1 : 0
+
+/**
+ * What selection reads from a meaning record: the bytes it claims, when it was written, how severe it is.
+ * An unreadable record matches no bytes (its own row still reads and refuses it); a record with no
+ * readable written_at sorts newest, so the barrier reads it and refuses it as malformed.
+ */
+function claimOf(path) {
+	let record
+	try {
+		record = readJsonFile(path)
+	} catch {
+		return null
+	}
+	const at = Date.parse(record?.written_at)
+	return { path, hash: record?.artifact_sha256 ?? null, at: Number.isNaN(at) ? Infinity : at, severity: severityOf(Array.isArray(record?.defects) ? record.defects : []) }
+}
+
+/** Newest written_at first; on equal times the more severe verdict first. File names never decide. */
+const newestFirst = (a, b) => (a.at === b.at ? b.severity - a.severity : b.at > a.at ? 1 : -1)
+
+/**
+ * One meaning record per delivered edition, bound to that edition's bytes. Every record whose
+ * artifact_sha256 equals the edition's current bytes (a PDF counts its --rendered-from bytes) is a
+ * candidate: its own fidelity-meaning-defects.<format>.json, another edition's record (a
+ * byte-identical copy, or the html edition a PDF renders), and the legacy session record. The
+ * newest reader run wins; on equal times the more severe verdict wins. When no record claims these
+ * bytes the target is its own record (refused as for a different edition), else the legacy record,
+ * else its own name, so the refusal names the file to write (meaning gate not run).
+ */
+function perEditionMeaning(sessionDir, delivered) {
+	if (delivered.length === 0) return [sessionTarget(sessionDir, MEANING_RECORD)]
+	const legacy = join(sessionDir, MEANING_RECORD)
+	const editions = readdirSync(sessionDir).filter((name) => EDITION_MEANING.test(name)).map((name) => join(sessionDir, name))
+	const claims = [...editions, ...(existsSync(legacy) ? [legacy] : [])].map(claimOf).filter((claim) => claim !== null)
+	return perEdition(sessionDir, delivered).map((target) => {
+		const own = join(sessionDir, meaningRecordName(target.format))
+		const bytes = target.subjects.length > 0 ? hashOf(target.subjects[0]) : null
+		const [newest] = bytes === null ? [] : claims.filter((claim) => claim.hash === bytes).sort(newestFirst)
+		return { ...target, declared: false, path: newest?.path ?? (existsSync(own) ? own : existsSync(legacy) ? legacy : own) }
+	})
+}
 
 /** Every fidelity record the barrier reads, in check order; each column is one rule the barrier applies. */
 export const FIDELITY_RECORDS = Object.freeze([
@@ -53,7 +110,7 @@ export const FIDELITY_RECORDS = Object.freeze([
 		kind: "fidelity",
 		file: FIDELITY_RECORD,
 		step: "fidelity gate",
-		targets: perEdition,
+		targets: perEditionAndSession,
 		requiredWhen: ({ hasFidelity }, target) => hasFidelity || GATED_FORMATS.includes(target.format),
 		remedy: (target) => `run fact verify on ${target.subjects[0] ?? "the edition"} and set it with --verified-by`,
 		bindsTo: "artifact_sha256",
@@ -64,17 +121,25 @@ export const FIDELITY_RECORDS = Object.freeze([
 		kind: "meaning",
 		file: MEANING_RECORD,
 		step: "meaning gate",
-		targets: perSession(MEANING_RECORD),
+		targets: perEditionMeaning,
 		requiredWhen: meaningRequired,
-		remedy: () => "run fact pairs and fact meaning-check before delivery",
+		remedy: (target) => `run fact pairs and fact meaning-check --edition ${target.format} on ${target.subjects[0] ?? "the edition"} before delivery`,
 		bindsTo: "artifact_sha256",
 		blocking: blocksDelivery,
 		payload: Object.freeze(["command", "status", "exitCode", "run_id", "pairs_sha256", "counts", "dropped", "unverified", "calibration_path", "calibration_written", "calibration_replaced", "promotion_eligibility"]),
 	}),
 ])
 
+// Collection warnings use the same envelope, but are not delivery-gate records.
+const SOURCE_RECORDS = Object.freeze([
+	Object.freeze({
+		kind: "source_conversion",
+		payload: Object.freeze(["conversion_altered_numbers", "lost", "raw_count", "converted_count"]),
+	}),
+])
+
 const entryOf = (kind) => {
-	const entry = FIDELITY_RECORDS.find((row) => row.kind === kind)
+	const entry = [...FIDELITY_RECORDS, ...SOURCE_RECORDS].find((row) => row.kind === kind)
 	if (entry === undefined) throw new CliError(`unknown fidelity record kind ${kind}`)
 	return entry
 }
@@ -124,19 +189,20 @@ export function readFidelityRecord(path, kind) {
 }
 
 const unresolved = (format, codes, path) => ({ code: "fidelity_unresolved", format, codes, message: codes.map((code) => deliveryBlockReason({ code })).join("; "), path })
-const hashOf = (path) => (existsSync(path) ? sha256Of(readFileSync(path)) : null)
 
 /** Barrier problems for `outcome verify` and `outcome finish`; empty when nothing blocks delivery. */
 export function fidelityProblems(sessionDir, manifest) {
 	const delivered = manifest.deliverables.filter((row) => row.status === "delivered")
-	const hasFidelity = existsSync(join(sessionDir, LEDGER_FILENAME)) || FIDELITY_RECORDS.some((entry) => existsSync(join(sessionDir, entry.file)))
+	const targets = FIDELITY_RECORDS.map((entry) => [entry, entry.targets(sessionDir, delivered)])
+	// Any session record a row did not name (a session fidelity record, a meaning record) is fidelity evidence.
+	const hasFidelity = existsSync(join(sessionDir, LEDGER_FILENAME)) || targets.some(([, list]) => list.some((target) => !target.declared && target.path !== null && existsSync(target.path)))
 	const lastFidelity = manifest.gateHistory?.findLast((entry) => entry.gate === "fidelity")
 	const exempt = !hasFidelity && manifest.gates.fidelity === "not_run" && lastFidelity?.status === "not_run" && Boolean(lastFidelity.reason?.trim())
 	const context = { sessionDir, hasFidelity }
 	const problems = []
 	const counted = new Set()
-	for (const entry of FIDELITY_RECORDS) {
-		for (const target of entry.targets(sessionDir, delivered)) {
+	for (const [entry, list] of targets) {
+		for (const target of list) {
 			const refuse = (message, path = target.path) => problems.push({ code: "edition_unverified", format: target.format, message: `${target.at}${message}`, path })
 			if (target.path === null || !existsSync(target.path)) {
 				if (target.declared) refuse(`${entry.kind} record ${target.path} is missing`)
@@ -151,10 +217,11 @@ export function fidelityProblems(sessionDir, manifest) {
 				continue
 			}
 			if (target.subjects.length > 0 && !target.subjects.some((subject) => hashOf(subject) === record[entry.bindsTo])) {
-				refuse(`${entry.kind} record ${target.path} is for a different edition than ${target.subjects.join(", ")}`)
+				refuse(`${entry.kind} record ${target.path} is for a different edition than ${target.subjects.join(", ")}; ${entry.remedy(target)}`)
 			}
-			if (counted.has(target.path)) continue
-			counted.add(target.path)
+			const path = realpathSync.native(target.path)
+			if (counted.has(path)) continue
+			counted.add(path)
 			const codes = [...new Set(record.defects.filter(entry.blocking).map((defect) => defect.code))].sort()
 			if (codes.length > 0) problems.push(unresolved(target.format, codes, target.path))
 		}

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-snapshot-readability.mjs

@@ -0,0 +1,49 @@
+// Availability is checked before hash/locator checks, including the raw-byte snapshot contract.
+// One code (snapshot_hash_mismatch) for every unreadable or changed snapshot; the message names the cause.
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { sha256Of } from "./cli-support.mjs"
+
+function read(dir, file) {
+	try {
+		return readFileSync(join(dir, file))
+	} catch (error) {
+		if (error.code === "ENOENT") throw new Error(`${file} is missing`)
+		if (error.code === "EISDIR") throw new Error(`${file} is not a readable file`)
+		throw new Error(`${file} is unreadable (${error.code ?? error.message})`)
+	}
+}
+
+/** Why the snapshot behind `row` cannot be trusted, or null when it reads and matches its pinned hash. */
+export function snapshotCause(sourcesDir, row) {
+	if (!sourcesDir) return "has no sources directory"
+	const dir = join(sourcesDir, row.source_id)
+	try {
+		let meta
+		try {
+			meta = JSON.parse(read(dir, "meta.json").toString("utf8"))
+		} catch (error) {
+			throw error instanceof SyntaxError ? new Error("meta.json is not valid JSON") : error
+		}
+		if (!meta || typeof meta.sha256 !== "string") return "has invalid snapshot metadata (meta.json has no sha256)"
+		const needsRaw = ["bytes", "utf8-bytes"].includes(row.locator?.unit) && meta.kind !== "converted-only"
+		const file = existsSync(join(dir, "raw.bin")) || needsRaw ? "raw.bin" : "text.txt"
+		return sha256Of(read(dir, file)) === meta.sha256 ? null : `hash mismatch: ${file} changed after its snapshot was pinned`
+	} catch (error) {
+		return error.message
+	}
+}
+
+/** Flags each cited row whose own snapshot is unreadable; returns those source ids so healthy sources keep their metadata. */
+export function unreadableSnapshots(ctx, rows, cited, sourcesDir, out) {
+	const unreadable = new Set()
+	for (const [id, node] of cited) {
+		const row = rows.get(id)
+		if (!row?.source_id) continue
+		const cause = snapshotCause(sourcesDir, row)
+		if (cause === null) continue
+		unreadable.add(row.source_id)
+		out.push({ ...ctx.defect("snapshot_hash_mismatch", node, `${id}: snapshot ${row.source_id} ${cause}`), fact_id: id })
+	}
+	return unreadable
+}

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-sources.mjs

@@ -0,0 +1,76 @@
+// Source integrity and raw quote anchoring, shared by the fidelity value checks. Fails closed:
+// a cited source-backed row whose sources dir, meta.json, raw.bin, or text.txt cannot be read, or
+// whose snapshot no longer matches its pin, gets snapshot_hash_mismatch (with fact_id) naming the
+// cause; healthy sources keep their metadata and checks. flag is (code, node, message, extra).
+import { join } from "node:path"
+
+import { proseText } from "./html-lite.mjs"
+import { reanchor } from "./raw-locator.mjs"
+import { readSnapshot } from "./source-view.mjs"
+
+const short = (hash) => String(hash ?? "none").slice(0, 12)
+
+function snapshotOf(sourcesDir, id) {
+	if (!sourcesDir) throw new Error("has no sources directory")
+	return readSnapshot(join(sourcesDir, id))
+}
+
+const blocked = (flag, cited, row, id, cause) => flag("snapshot_hash_mismatch", cited.get(row.fact_id), `${row.fact_id}: snapshot ${id} ${cause}`, { fact_id: row.fact_id })
+
+/** One source's checks for the rows that cite it; byte-located rows are re-anchored on the view. */
+function rowChecks(snap, id, referenced, cited, flag) {
+	const converted = snap.view.mode === "converted"
+	for (const row of referenced) {
+		const node = cited.get(row.fact_id)
+		// No locator unit marks a legacy text.txt row: it holds only on the legacy snapshot it pins.
+		if (row.locator?.unit === undefined) {
+			if (snap.view.mode !== "legacy") blocked(flag, cited, row, id, `is no longer the legacy text.txt snapshot the row was located on (now ${snap.view.mode}); add the row again from the new snapshot`)
+			else if (row.snapshot_sha256 !== snap.sha256) blocked(flag, cited, row, id, `holds ${short(snap.sha256)} but the legacy row pins ${short(row.snapshot_sha256)}`)
+			continue
+		}
+		if (snap.view.mode === "legacy") {
+			blocked(flag, cited, row, id, "raw.bin is missing (the row is byte-located)")
+			continue
+		}
+		if (converted && row.kind !== "quote") {
+			flag("snapshot_not_raw", node, `${row.fact_id} cannot measure converted-only source ${id}`)
+			continue
+		}
+		if (row.snapshot_sha256 !== snap.sha256) {
+			blocked(flag, cited, row, id, `holds ${short(snap.sha256)} but the row pins ${short(row.snapshot_sha256)}; run source refresh ${id} to re-anchor`)
+			continue
+		}
+		const anchor = row.locator.artifact === snap.view.artifact ? reanchor(snap.view, row) : null
+		if (!anchor) flag("quote_not_verbatim", node, `${row.fact_id}: no unique exact quote and context in ${id}/${snap.view.artifact}`)
+		else if (anchor.relocated) flag("relocated", node, `${row.fact_id}: ${row.locator.char_start}:${row.locator.char_end} -> ${anchor.start}:${anchor.end} (bytes of ${id}/${snap.view.artifact})`)
+		if (converted && row.kind === "quote") flag("quote_converted_only", node, `${row.fact_id} quotes converted-only source ${id}, not the original fetched bytes`)
+	}
+}
+
+export function sourceChecks(ctx, rows, cited, sourcesDir, flag, unreadable = new Set()) {
+	const referenced = new Map()
+	for (const key of cited.keys()) {
+		const row = rows.get(key)
+		if (row?.source_id) referenced.set(row.source_id, [...(referenced.get(row.source_id) ?? []), row])
+	}
+	const ids = new Set(referenced.keys())
+	for (const match of proseText(ctx.body).matchAll(/\[S(\d+)\]/g)) ids.add(`S${match[1]}`)
+	const meta = new Map()
+	for (const id of ids) {
+		if (unreadable.has(id)) continue
+		const backing = referenced.get(id) ?? []
+		let snap
+		try {
+			snap = snapshotOf(sourcesDir, id)
+		} catch (error) {
+			// A source only named in prose ([S<n>]) backs no row: an absent snapshot is not a finding.
+			for (const row of backing) blocked(flag, cited, row, id, error.message)
+			continue
+		}
+		meta.set(id, snap.meta)
+		if (snap.drift.length === 0) rowChecks(snap, id, backing, cited, flag)
+		else if (backing.length === 0) flag("snapshot_hash_mismatch", ctx.body, `snapshot ${id} ${snap.drift.join("; ")}`)
+		else for (const row of backing) blocked(flag, cited, row, id, snap.drift.join("; "))
+	}
+	return meta
+}

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-trace.mjs

@@ -13,9 +13,12 @@
 // so each entry, in array order, is matched to the next untraced occurrence of its rendered text in
 // document order that is a whole numeral and reads as the entry's row there (fits: "1,237 million"
 // is not F2's 1,237), and strips that one occurrence only. A copy of the same text that no entry
-// accounts for stays in the scan; an entry whose text is gone strips nothing.
+// accounts for stays in the scan; an entry whose text is gone strips nothing. A derived or
+// converted entry is located under the bracket grammar of fidelity-originals.mjs (renderLocator).
 
+import { PROSE_TAGS } from "./html-lite.mjs"
 import { NOT_CLAIMS } from "./numerals.mjs"
+import { sourcesClaims, textClaims } from "./sources-citation.mjs"
 
 /** Structural numerals: versions, figure/table/section references, times (NOT_CLAIMS 7-11), pages, citations, placeholders. */
 export const STRUCTURAL = [...NOT_CLAIMS.slice(7, 12), /\b(?:p|pp|page|pages)\.?\s*\d+(?:\s*[-\u2013]\s*\d+)?/gi, /\[(?:S|Source\s*)\d+\]|\[\^\d+\]/gi, /\{\{[^}]*\}\}/g]
@@ -29,7 +32,12 @@ function ownerTexts(ctx, charts) {
 	const owners = new Map()
 	for (const entry of ctx.texts) {
 		const kind = ctx.kindOf(entry.scope)
-		if (kind === "sources" || kind === "toc") continue
+		if (kind === "toc") continue
+		if (kind === "sources") {
+			if (!PROSE_TAGS.has(entry.owner.tag)) owners.set(entry.owner, `${owners.get(entry.owner) ?? ""} ${textClaims(entry.node.text).join(" ")}`)
+			else if (!owners.has(entry.owner)) owners.set(entry.owner, sourcesClaims(entry.owner).join(" "))
+			continue
+		}
 		if (charts.has(ctx.util.closest(entry.node, (cur) => cur.tag === "figure"))) continue
 		const hidden = ctx.util.closest(entry.node, (cur) => cur.attrs["data-fact"] !== undefined || cur.attrs["data-translates"] !== undefined || cur.tag === "q" || cur.tag === "blockquote")
 		owners.set(entry.owner, (owners.get(entry.owner) ?? "") + (hidden ? ` ${TRACED} ` : entry.node.text))
@@ -52,8 +60,13 @@ function scanOwner(ctx, owner, raw, flag) {
 	for (const match of rest.matchAll(NUMERAL)) flag("untraceable_number", owner, `number "${match[0]}" has no ledger row: "${clip(rest.slice(Math.max(0, match.index - 30), match.index + 30))}"`)
 }
 
+const plainSite = (entry, text, from) => {
+	const hit = text.indexOf(entry.rendered, from)
+	return hit === -1 ? null : [hit, hit + entry.rendered.length]
+}
+
 /** Strip each fill-map entry at its own fill site: the next untraced occurrence after the previous entry's site. */
-function traceFills(owners, fillMap, fits) {
+function traceFills(owners, fillMap, fits, locate = plainSite) {
 	const keys = [...owners.keys()]
 	const texts = [...owners.values()]
 	let [index, from] = [0, 0]
@@ -61,12 +74,12 @@ function traceFills(owners, fillMap, fits) {
 		const { rendered } = entry
 		if (!rendered) continue
 		for (let i = index, at = from; i < texts.length; i += 1, at = 0) {
-			let hit = texts[i].indexOf(rendered, at)
-			const glued = (pos) => /\d/.test(texts[i][pos - 1] ?? "") || /\d/.test(texts[i][pos + rendered.length] ?? "")
-			while (hit !== -1 && (glued(hit) || !fits(entry, texts[i].slice(hit)))) hit = texts[i].indexOf(rendered, hit + 1)
-			if (hit === -1) continue
-			texts[i] = `${texts[i].slice(0, hit)}${TRACED}${texts[i].slice(hit + rendered.length)}`
-			;[index, from] = [i, hit + TRACED.length]
+			let hit = locate(entry, texts[i], at)
+			const glued = ([start, end]) => (/^\d/.test(rendered) && /\d/.test(texts[i][start - 1] ?? "")) || (/\d$/.test(rendered) && /\d/.test(texts[i][end] ?? ""))
+			while (hit && (glued(hit) || !fits(entry, texts[i].slice(hit[0])))) hit = locate(entry, texts[i], hit[0] + 1)
+			if (!hit) continue
+			texts[i] = `${texts[i].slice(0, hit[0])}${TRACED}${texts[i].slice(hit[1])}`
+			;[index, from] = [i, hit[0] + TRACED.length]
 			break
 		}
 	}
@@ -79,7 +92,8 @@ function traceFills(owners, fillMap, fits) {
  * @param {{ fact_id: string, rendered: string, start?: number, end?: number }[] | null} fillMap Markdown fill map, or null
  * @param {(code: string, node: object, message: string) => void} flag
  * @param {(entry: object, tail: string) => boolean} fits whether the text from a candidate site on reads as the entry's row
+ * @param {(entry: object, text: string, from: number) => [number, number] | null} [locate] the next candidate site of an entry's text
  */
-export function traceChecks(ctx, charts, fillMap, flag, fits) {
-	for (const [owner, text] of traceFills(ownerTexts(ctx, charts), fillMap, fits)) scanOwner(ctx, owner, text, flag)
+export function traceChecks(ctx, charts, fillMap, flag, fits, locate) {
+	for (const [owner, text] of traceFills(ownerTexts(ctx, charts), fillMap, fits, locate)) scanOwner(ctx, owner, text, flag)
 }

package/packages/shared-skills/skills/ulw-research/scripts/fidelity-value-unit.mjs

@@ -0,0 +1,202 @@
+// Value-mode units live outside the fact element. The documented form is the value then its unit,
+// with or without a space, a Korean particle allowed after it ({{F1:span:value}} m, {{F3:rate:value}}%,
+// {{F21:rev:value}}\uC5B5 \uC6D0\uC73C\uB85C); a currency sign right before the value; the :unit element
+// right after it; or the same visual column's table header. A currency the element's own text carries (fill renders a
+// prefix currency value from its raw text, $<data>$12</data>) binds too: every bound sign, outside or inside, must agree. Unknown words are advisory, never guessed units,
+// unless fill recorded a bound unit for the value: then losing it is a unit edit.
+import { cellsOf, rowsOf } from "./fact-locate.mjs"
+import { unitKey } from "./fidelity-binding.mjs"
+import { parseHtml, proseText } from "./html-lite.mjs"
+import { NUMBER_SOURCE } from "./number-grammar.mjs"
+import { QUALIFIERS_AFTER } from "./numerals.mjs"
+import { dimensionOf, normalizeUnit, spacedAliasUnit } from "./units.mjs"
+
+// Korean particles a unit may carry (eun/neun, i/ga, eul/reul, ui, e, eseo, ege, euro/ro, wa/gwa, do, man,
+// kkaji, buteo, boda, ssik, in, ida/yeotda/ieotda, imyeo, igo), longest first.
+const PARTICLES = ["\uC774\uC5C8\uB2E4", "\uC600\uB2E4", "\uC774\uB2E4", "\uC774\uBA70", "\uC774\uACE0", "\uC73C\uB85C", "\uC5D0\uC11C", "\uC5D0\uAC8C", "\uAE4C\uC9C0", "\uBD80\uD130", "\uBCF4\uB2E4", "\uC740", "\uB294", "\uC774", "\uAC00", "\uC744", "\uB97C", "\uC758", "\uC5D0", "\uB85C", "\uC640", "\uACFC", "\uB3C4", "\uB9CC", "\uC529", "\uC778"]
+/** The displayed value, read with the one grouped-number grammar; text around it is sign and unit. */
+const NUMBER = new RegExp(NUMBER_SOURCE, "u")
+const SIGNS = ["US$", "$", "\u20AC", "\u20A9", "\u00A3", "\u00A5", "USD", "EUR", "GBP", "JPY", "KRW"]
+
+const withoutSuffix = (word, suffixes) => {
+	const suffix = suffixes.find((cur) => word.endsWith(cur) && word.length > cur.length)
+	return suffix ? word.slice(0, -suffix.length) : word
+}
+const withoutParticle = (word) => withoutSuffix(word, PARTICLES)
+/** Words written after a value that bound or soften it (the numeral qualifiers, jeongdo, garyang, jjeum, gwaban). */
+const QUALIFIER_WORDS = [...QUALIFIERS_AFTER, "\uC815\uB3C4", "\uAC00\uB7C9", "\uCBE4", "\uACFC\uBC18"]
+/** A unit, with a particle and/or a qualifier glued on ("m\uC774\uC0C1\uC758"); a whole qualifier word is never a unit (chogwa is not cho + gwa). */
+const stemsOf = (word) => {
+	const bare = withoutParticle(word)
+	return QUALIFIER_WORDS.includes(word) ? [] : [word, bare, withoutSuffix(word, QUALIFIER_WORDS), withoutSuffix(bare, QUALIFIER_WORDS)].filter((stem) => !QUALIFIER_WORDS.includes(stem))
+}
+const stemOf = (word) => stemsOf(word).find((stem) => normalizeUnit(stem)) ?? null
+const unitOf = (word) => normalizeUnit(stemOf(word))
+/** Unit aliases that are also ordinary English words ("won awards", "second place"): read only as the row's own unit. */
+const ORDINARY_WORDS = new Set(["won", "second", "pound", "pounds"])
+/** An ordinary word, or an all-caps acronym that only matches a unit case-insensitively ("SEC filings", "WON"). */
+const ordinary = (word) => ORDINARY_WORDS.has(word.toLowerCase()) || (/^[A-Z]{3,}$/.test(word) && normalizeUnit(word) !== word)
+/** Inline elements the text after a value is read through; any other element, or another fact, ends it. */
+const INLINE = new Set(["a", "abbr", "b", "bdi", "cite", "code", "data", "dfn", "em", "i", "ins", "kbd", "mark", "samp", "small", "span", "strong", "sub", "sup", "time", "u", "var"])
+/** "3 bun-ui 1" is the fraction one third, not 3 minutes. */
+const FRACTION = /^\uBD84\uC758\s?\d/u
+const scaleOf = (unit) => /-(e\d+)$/.exec(unit ?? "")?.[1] ?? null
+
+/** English words stay apart: letter-only words join only as a spaced alias ("percentage points"), so "m in" is m, then in. */
+const LETTERS = /^[A-Za-z]+$/u
+/** The unit the words spell together: a spaced alias, or (with a symbol or Hangul in them) the words joined ("% p", "\uD37C\uC13C\uD2B8 \uD3EC\uC778\uD2B8"). */
+function unitOfWords(words) {
+	if (words.length === 1) return unitOf(words[0])
+	const spaced = stemsOf(words.at(-1)).map((last) => spacedAliasUnit([...words.slice(0, -1), last].join(" "))).find(Boolean)
+	return spaced ?? (words.every((word) => LETTERS.test(word)) ? null : unitOf(words.join("")))
+}
+
+/** The unit written right after the value: the longest known unit its first words spell ("% \uD3EC\uC778\uD2B8" is %p, not %), else the next word. */
+function unitAfter(text, row) {
+	const lead = text.replace(/^[\s\u00A0]+/u, "")
+	if (FRACTION.test(lead)) return null
+	const bracketed = /^\(([^()]{1,40})\)/u.exec(lead)
+	if (bracketed) return unitAfter(bracketed[1], row)
+	const clause = lead.split(/[,.;:!?()[\]"]/u)[0]
+	const words = clause.split(/[\s\u00A0]+/u).filter(Boolean).slice(0, 3)
+	if (words.length === 0) return null
+	for (let n = words.length; n > 1; n--) {
+		const unit = unitOfWords(words.slice(0, n))
+		if (unit) return { token: unit }
+	}
+	const first = unitOf(words[0])
+	if (!first) return null
+	// An ordinary word ("pounds", "won awards") counts only as the row's unit or beside a sign or header of its kind (boundUnits).
+	if (unitKey(first) !== unitKey(row.unit) && ordinary(stemOf(words[0]))) return { token: first, ordinary: true }
+	const currency = words[1] ? unitOf(words[1]) : null
+	if (dimensionOf(first) === "scale" && dimensionOf(currency)?.startsWith("currency:")) return { token: `${currency} ${words[0]}`, dimension: dimensionOf(currency), scale: first }
+	return { token: first }
+}
+
+function signBefore(text) {
+	const trimmed = text.replace(/[\s\u00A0]+$/u, "")
+	// A letter sign is a whole word: "USD 12", never "XUSD 12".
+	const sign = SIGNS.find((s) => trimmed.endsWith(s) && !(/^[A-Z]/u.test(s) && /[A-Za-z]$/u.test(trimmed.slice(0, -s.length))))
+	return sign ? { token: normalizeUnit(sign), sign: true } : null
+}
+
+/** A currency written after the number inside the element ("12\u20AC", "12\uC6D0"); any other unit there is part of the value. */
+function currencyAfter(text, row) {
+	const found = unitAfter(text, row)
+	const dimension = found && !found.ordinary ? (found.dimension ?? dimensionOf(found.token)) : null
+	return dimension?.startsWith("currency:") ? { token: found.scale ? dimension.slice("currency:".length) : found.token, sign: true } : null
+}
+
+function agrees(found, row) {
+	if (found.scale) return dimensionOf(row.unit) === found.dimension && scaleOf(row.unit) === found.scale
+	if (unitKey(found.token) === unitKey(row.unit)) return true
+	if (dimensionOf(found.token) === "scale") return scaleOf(row.unit) === found.token
+	if (dimensionOf(found.token)?.startsWith("currency:") && found.sign) return dimensionOf(row.unit) === dimensionOf(found.token)
+	return unitKey(found.token) === unitKey(row.unit)
+}
+
+const closest = (node, test) => {
+	for (let cur = node.parent; cur; cur = cur.parent) if (test(cur)) return cur
+	return null
+}
+/** All text under a node, code included: a unit may be set in code ("320 <code>ms</code>"). */
+const plainText = (node) => (node.tag === "#text" ? node.text : node.children.map(plainText).join(""))
+
+/** A column-header row: a thead row or a row made only of th cells. A th first in a body row is a row header. */
+const isHeaderRow = (row) => row.parent?.tag === "thead" || (cellsOf(row).length > 0 && cellsOf(row).every((cur) => cur.tag === "th"))
+
+/** The header of the cell's visual column; nothing binds in a table with a rowspan or without a header row. */
+function headerUnit(node) {
+	const cell = closest(node, (cur) => cur.tag === "td")
+	const table = cell && closest(cell, (cur) => cur.tag === "table")
+	if (!table || cell.attrs.colspan || cell.attrs.rowspan) return null
+	const rows = rowsOf(table)
+	if (rows.some((row) => row.children.some((cur) => cur.attrs?.rowspan && cur.attrs.rowspan !== "1"))) return null
+	const header = rows.find(isHeaderRow)
+	if (!header || header === cell.parent) return null
+	const head = cellsOf(header)[cellsOf(cell.parent).indexOf(cell)]
+	if (!head) return null
+	const text = proseText(head)
+	const label = (/\(([^()]+)\)\s*$/u.exec(text)?.[1] ?? text).trim()
+	const unit = unitOf(label) ?? unitOf(label.split(/\s+/u).at(-1) ?? "")
+	return unit ? { token: unit } : null
+}
+
+/** The documented split form: the next element is this fact's own :unit element. */
+function unitElementAfter(siblings, at, row) {
+	const next = siblings.slice(at + 1).find((cur) => !(cur.tag === "#text" && !cur.text.trim()))
+	return next?.attrs?.["data-fact"] === row.fact_id && unitKey(proseText(next)) === unitKey(row.unit)
+}
+
+/** The text after the element within its block, read through inline wrappers and line breaks ("320 <b>m</b>", "<b>320</b> m", "320<br>m"). */
+function textAfter(node) {
+	let text = ""
+	for (let cur = node; text.length < 80; ) {
+		const next = cur.parent?.children[cur.parent.children.indexOf(cur) + 1]
+		if (next === undefined) {
+			if (!INLINE.has(cur.parent?.tag) || cur.parent.attrs["data-fact"] !== undefined) break
+			cur = cur.parent
+		} else if (next.tag === "#text" || next.tag === "br" || (INLINE.has(next.tag) && next.attrs["data-fact"] === undefined)) {
+			text += next.tag === "br" ? "\n" : plainText(next)
+			cur = next
+		} else break
+	}
+	return text
+}
+
+const INSIDE = "written inside with"
+/**
+ * Every unit bound to a value-mode element: a currency sign before it, the unit after it (or its :unit element), its
+ * column header, and a currency sign or word inside it (prefix or suffix of the number).
+ */
+function boundUnits(node, row) {
+	const siblings = node.parent.children
+	const at = siblings.indexOf(node)
+	const prev = siblings[at - 1]
+	const shown = proseText(node)
+	const number = NUMBER.exec(shown)
+	const before = signBefore(prev?.tag === "#text" ? prev.text : "")
+	// The element's own text is the row's render: a scale word in it ("3,234\uC5B5", "12 million") is part of the value.
+	const inside = number ? [signBefore(shown.slice(0, number.index)), currencyAfter(shown.slice(number.index + number[0].length), row)] : []
+	const read = unitAfter(textAfter(node), row) ?? (unitElementAfter(siblings, at, row) ? { token: row.unit } : null)
+	const header = headerUnit(node)
+	const kind = (unit) => dimensionOf(unit.token)?.split(":")[0]
+	const after = read?.ordinary && ![before, ...inside, header].some((unit) => unit && kind(unit) === kind(read)) ? null : read
+	return [["preceded by", before], ["followed by", after], ["headed with", header], ...inside.map((unit) => [INSIDE, unit])].filter(([, unit]) => unit)
+}
+
+/** Each data-fact element's own fill-map entry: fill writes one element per entry, so ids pair up in document order. */
+export function fillEntriesByNode(nodes, entries) {
+	const queues = new Map()
+	for (const entry of entries ?? []) if (entry.replaced === undefined && entry.translates === undefined) queues.set(entry.fact_id, [...(queues.get(entry.fact_id) ?? []), entry])
+	return new Map(nodes.filter((node) => node.attrs["data-replaced"] === undefined).flatMap((node) => {
+		const entry = queues.get(node.attrs["data-fact"])?.shift()
+		return entry ? [[node, entry]] : []
+	}))
+}
+
+/** Fill's record of the unit bound to each value-mode pointer (unit_bound), read off the filled edition (HTML, or the Markdown projection). */
+export function withBoundUnits(html, entries, rows) {
+	const all = (node) => [node, ...node.children.flatMap(all)]
+	const filled = fillEntriesByNode(all(parseHtml(html)).filter((node) => node.attrs?.["data-fact"] !== undefined), entries)
+	const units = new Map([...filled].flatMap(([node, entry]) => {
+		const row = rows.get(entry.fact_id)
+		// Only a unit outside the element: the element's own text is the row's render, so it can be no record of a unit beside it.
+		const unit = entry.mode === "value" && row && unitKey(row.unit) ? boundUnits(node, row).find(([where]) => where !== INSIDE)?.[1].token : null
+		return unit ? [[entry, unit]] : []
+	}))
+	return entries.map((entry) => (units.has(entry) ? { ...entry, unit_bound: units.get(entry) } : entry))
+}
+
+/**
+ * Value mode comes from fill: the element's data-fact-mode, or its fill-map entry when the edition has one
+ * (so deleting the attribute changes nothing). `entry.unit_bound` is the unit fill saw bound to the value.
+ */
+export function valueUnitProblem(node, row, entry = null) {
+	if ((entry?.mode !== "value" && node.attrs["data-fact-mode"] !== "value") || !unitKey(row.unit)) return null
+	const found = boundUnits(node, row)
+	if (entry?.unit_bound && found.every(([where]) => where === INSIDE)) return ["unit_mismatch", `value-mode ${row.fact_id} had the unit "${entry.unit_bound}" beside it when filled, but no recognizable unit is bound beside it now; its row is in "${row.unit}"`]
+	if (found.length === 0) return ["unit_unbound", `${row.fact_id} has unit "${row.unit}" but no recognizable unit right after its value, before it as a currency sign, or in its column header`]
+	const wrong = found.find(([, unit]) => !agrees(unit, row))
+	return wrong ? ["unit_mismatch", `value-mode ${row.fact_id} is ${wrong[0]} "${wrong[1].token}", but its row is in "${row.unit}"`] : null
+}