oh-my-opencode 5.1.47 → 5.1.51

package/dist/skills/ulw-research/scripts/fact-unit-rules.test.ts

@@ -1,238 +1,12 @@
 import { describe, expect, test } from "bun:test"
-
-import { derive, display, recompute } from "./fact-derive.mjs"
+import { display, recompute } from "./fact-derive.mjs"
+import { derive } from "./tests/derive-clock"
 import { parseExpr } from "./fact-expr.mjs"
 import { addRow, emptyLedger, OPERATIONS } from "./fact-ledger.mjs"
 import { canonicalUnit, expectedUnit, isAffine, OPERATION_RULES, renderPrecision } from "./unit-rules.mjs"
+import { Row, Ledger, Spec, HASH, measured, ledger, PCT_SUM, VALID, PRECISION, RELABELS, Mutation, generic, repeatFirst, operands, MALFORMED, REPEATED, rowOf, relabel, OPS } from "./tests/fact-unit-rules-support"
 
-// Property checks of references/unit-rules.md: every case table below is keyed by the registry's own operation list,
-// so a new operation without valid, relabel, and malformed cases fails here.
-
-type Row = Record<string, unknown>
-type Ledger = { schemaVersion: number; rows: Row[]; events: unknown[] }
-type Spec = Record<string, unknown>
-
-const HASH = "a".repeat(64)
-
-function measured(factId: string, value: string, unit: string | null, extra: Row = {}): Row {
-	return {
-		fact_id: factId,
-		kind: "measured",
-		value,
-		unit,
-		raw: `${value} ${unit ?? ""}`.trim(),
-		quote: `The figure is ${value}.`,
-		source_id: "S1",
-		locator: { artifact: "sources/S1/text.txt", char_start: 0, char_end: 20 },
-		snapshot_sha256: HASH,
-		extracted_by: "fact add --find",
-		observed_at: "2026-10-23T08:00:00Z",
-		label: factId.toLowerCase(),
-		...extra,
-	}
-}
-
-function ledger(): Ledger {
-	const built = emptyLedger() as Ledger
-	const rows = [
-		measured("F1", "1", "m"),
-		measured("F2", "3", "m"),
-		measured("F3", "20", "%"),
-		measured("F4", "15", "%"),
-		measured("F5", "5", "%p"),
-		measured("F6", "100", "case", { valid_at: "2025", entity: "acme" }),
-		measured("F7", "112", "case", { valid_at: "2026", entity: "acme" }),
-		measured("F8", "40", "person"),
-		measured("F9", "200", "person"),
-		measured("F10", "100", "USD"),
-		measured("F11", "20", "USD/person"),
-		measured("F12", "0", "m"),
-		measured("F13", "25", "C", { valid_at: "2025", entity: "x" }),
-		measured("F14", "30", "C", { valid_at: "2026", entity: "x" }),
-		measured("F15", "0", "person"),
-		measured("F16", "2.5", "kilometre"),
-		measured("F17", "120", "case", { valid_at: "2026", entity: "other" }),
-		measured("F18", "0", "case", { valid_at: "2025", entity: "acme" }),
-		measured("F19", "-5", "person"),
-		measured("F20", "2", "%p"),
-		measured("F21", "105", "case", { valid_at: "2025", entity: "acme" }),
-		measured("F22", "200", "person"),
-	]
-	for (const row of rows) addRow(built, row)
-	return built
-}
-
-const PCT_SUM = { op: "sum", operands: ["F3", "F4"], unit: "%", disjoint: true, reference: "all respondents", rationale: "disjoint answer shares" }
-
-const VALID: Record<string, Array<{ spec: Spec; unit: string | null; precision?: "places" | "sigfigs" }>> = {
-	sum: [
-		{ spec: { op: "sum", operands: ["F1", "F2"], unit: "m" }, unit: "m" },
-		{ spec: { op: "sum", operands: ["F1", "F2"], unit: "metre" }, unit: "m" },
-		{ spec: PCT_SUM, unit: "%" },
-	],
-	diff: [
-		{ spec: { op: "diff", operands: ["F2", "F1"], unit: "m" }, unit: "m" },
-		{ spec: { op: "diff", operands: ["F3", "F4"], unit: "pp" }, unit: "%p" },
-		{ spec: { op: "diff", operands: ["F3", "F5"], unit: "%" }, unit: "%" },
-		{ spec: { op: "diff", operands: ["F5", "F20"], unit: "%p" }, unit: "%p" },
-	],
-	growth: [{ spec: { op: "growth", from: "F6", to: "F7", unit: "%" }, unit: "%" }],
-	share: [
-		{ spec: { op: "share", part: "F8", whole: "F9", unit: "%" }, unit: "%" },
-		{ spec: { op: "share", part: "F22", whole: "F9", unit: "%" }, unit: "%" },
-	],
-	ratio: [
-		{ spec: { op: "ratio", num: "F10", den: "F11", unit: "person" }, unit: "person" },
-		{ spec: { op: "ratio", num: "F1", den: "F2", unit: null }, unit: null },
-		{ spec: { op: "ratio", num: "F10", den: "F9", unit: "USD/person" }, unit: "USD/person" },
-	],
-	convert: [
-		{ spec: { op: "convert", operands: ["F12"], to: "km" }, unit: "km" },
-		{ spec: { op: "convert", operands: ["F16"], to: "m" }, unit: "m" },
-		{ spec: { op: "convert", operands: ["F2"], to: "kilometre" }, unit: "km" },
-	],
-	expr: [
-		{ spec: { op: "expr", formula: "F3 - F4", unit: "%p" }, unit: "%p", precision: "places" },
-		{ spec: { op: "expr", formula: "F2 - F1", unit: "m" }, unit: "m", precision: "places" },
-		{ spec: { op: "expr", formula: "F5", unit: "%p" }, unit: "%p", precision: "places" },
-		{ spec: { op: "expr", formula: "F1 * F1 / F2", unit: "m" }, unit: "m" },
-		{ spec: { op: "expr", formula: "F10 / F11", unit: "person" }, unit: "person" },
-		{ spec: { op: "expr", formula: "pct(F8 / F9)", unit: "%" }, unit: "%" },
-		{ spec: { op: "expr", formula: "F3 * F9", unit: "person" }, unit: "person" },
-	],
-}
-
-/** Invariant 5 per operation: sum and diff render by decimal places, the rest by significant figures (expr cases override). */
-const PRECISION: Record<string, "places" | "sigfigs"> = { sum: "places", diff: "places", growth: "sigfigs", share: "sigfigs", ratio: "sigfigs", convert: "sigfigs", expr: "sigfigs" }
-
-const RELABELS = [null, "%", "%p", "pp", "bp", "m", "metre", "km", "kilometre", "cm", "C", "case", "person", "USD", "USD/person", "person/USD", "KRW-e8"]
-
-type Mutation = { name: string; base: Spec; mutate: (row: Row, book: Ledger) => Row; reason: string }
-const generic = (base: Spec, arity: string[], arityReason = "takes ", missingReason = "no ledger row F999"): Mutation[] => [
-	{ name: "operands null", base, mutate: (row) => ({ ...row, operands: null }), reason: "operands must be a non-empty array" },
-	{ name: "operands empty", base, mutate: (row) => ({ ...row, operands: [] }), reason: "operands must be a non-empty array" },
-	{ name: "wrong arity", base, mutate: (row) => ({ ...row, operands: arity }), reason: arityReason },
-	{ name: "missing operand id", base, mutate: (row) => ({ ...row, operands: (row.operands as string[]).map((id, index) => (index === 0 ? "F999" : id)) }), reason: missingReason },
-	{ name: "invalid rational", base, mutate: (row) => ({ ...row, exact: { num: "x", den: "1" } }), reason: "exact must be { num, den }" },
-	{ name: "no operation", base, mutate: (row) => ({ ...row, operation: "mean" }), reason: 'operation "mean" is not one of' },
-	{ name: "repeated operand", base, mutate: (row) => ({ ...row, operands: repeatFirst(row.operands as string[]) }), reason: "is repeated" },
-	{ name: "self reference", base, mutate: (row) => ({ ...row, operands: (row.operands as string[]).map((id, index) => (index === 0 ? row.fact_id : id)) }), reason: "cites itself" },
-	{ name: "kind operation", base, mutate: (row) => ({ ...row, kind: "assumed" }), reason: "kind assumed" },
-	{ name: "audit fields", base, mutate: (row) => ({ ...row, factor: "999" }), reason: "factor" },
-	{ name: "precision field", base, mutate: (row) => ({ ...row, precision: { places: -1, sigfigs: 0 } }), reason: "precision" },
-	{ name: "compatibility field", base, mutate: (row) => ({ ...row, compatibility: "invalid" }), reason: "compatibility" },
-	{ name: "metadata fields", base, mutate: (row) => ({ ...row, population: { tampered: true } }), reason: "population" },
-	{ name: "noncanonical operand", base, mutate: (row, book) => {
-		const operand = book.rows.find((r) => r.fact_id === (row.operands as string[])[0])
-		if (!operand) throw Error("fixture operand missing")
-		operand.unit = `${operand.unit}*bp/%p`
-		return row
-	}, reason: "canonical" },
-]
-/** The first operand id in a second slot: [F1, F2] -> [F1, F1]; a one-operand row gets [F1, F1]. */
-const repeatFirst = (ids: string[]) => (ids.length === 1 ? [ids[0], ids[0]] : [...ids.slice(0, -1), ids[0]])
-const operands = (ids: string[]) => (row: Row) => ({ ...row, operands: ids })
-
-const MALFORMED: Record<string, Mutation[]> = {
-	sum: [
-		...generic(VALID.sum[0].spec, ["F1"]),
-		{ name: "no context", base: VALID.sum[0].spec, mutate: (row) => ({ ...row, context: null }), reason: "sum rows carry a context object" },
-		{ name: "% without disjoint", base: PCT_SUM, mutate: (row) => ({ ...row, context: { disjoint: false, reference: "all respondents" } }), reason: "needs disjoint shares" },
-		{ name: "% without reference", base: PCT_SUM, mutate: (row) => ({ ...row, context: { disjoint: true, reference: null } }), reason: "one shared reference" },
-		{ name: "% without rationale", base: PCT_SUM, mutate: (row) => ({ ...row, rationale: null }), reason: "needs a rationale" },
-		{ name: "unequal units", base: VALID.sum[0].spec, mutate: operands(["F1", "F8"]), reason: "unit differs" },
-		{ name: "affine units", base: VALID.sum[0].spec, mutate: operands(["F13", "F14"]), reason: "sum refuses affine" },
-		{ name: "closed context", base: VALID.sum[0].spec, mutate: (row) => ({ ...row, context: { disjoint: "true", reference: 7, extra: true } }), reason: "sum context" },
-		{ name: "share total", base: PCT_SUM, mutate: (row, book) => {
-			for (const operand of book.rows.filter((r) => ["F3", "F4"].includes(String(r.fact_id)))) Object.assign(operand, { value: "60", exact: { num: "60", den: "1" } })
-			return row
-		}, reason: "total <= 100" },
-	],
-	diff: [
-		...generic(VALID.diff[0].spec, ["F2", "F1", "F8"]),
-		{ name: "%p - % pair", base: VALID.diff[2].spec, mutate: operands(["F5", "F3"]), reason: '"%p" - "%" is not a typed pair' },
-		{ name: "unit - other unit pair", base: VALID.diff[0].spec, mutate: operands(["F1", "F8"]), reason: '"m" - "person" is not a typed pair' },
-		{ name: "affine units", base: VALID.diff[0].spec, mutate: operands(["F14", "F13"]), reason: "affine (temperature)" },
-		{ name: "stray context", base: VALID.diff[0].spec, mutate: (row) => ({ ...row, context: "x" }), reason: "diff rows carry no context" },
-	],
-	growth: [
-		...generic(VALID.growth[0].spec, ["F6"]),
-		{ name: "affine units", base: VALID.growth[0].spec, mutate: operands(["F13", "F14"]), reason: "growth refuses affine" },
-		{ name: "unequal units", base: VALID.growth[0].spec, mutate: operands(["F6", "F8"]), reason: "unit differs" },
-		{ name: "entity mismatch", base: VALID.growth[0].spec, mutate: operands(["F6", "F17"]), reason: "growth needs one declared entity" },
-		{ name: "one period", base: VALID.growth[0].spec, mutate: operands(["F6", "F21"]), reason: "two different valid_at periods" },
-		{ name: "from <= 0", base: VALID.growth[0].spec, mutate: operands(["F18", "F7"]), reason: "positive starting value in F18" },
-		{ name: "stray context", base: VALID.growth[0].spec, mutate: (row) => ({ ...row, context: { target: "km" } }), reason: "growth rows carry no context" },
-	],
-	share: [
-		...generic(VALID.share[0].spec, ["F8"]),
-		{ name: "affine units", base: VALID.share[0].spec, mutate: operands(["F13", "F14"]), reason: "share refuses affine" },
-		{ name: "unequal units", base: VALID.share[0].spec, mutate: operands(["F8", "F1"]), reason: "unit differs" },
-		{ name: "whole <= 0", base: VALID.share[0].spec, mutate: operands(["F8", "F15"]), reason: "positive whole in F15" },
-		{ name: "part < 0", base: VALID.share[0].spec, mutate: operands(["F19", "F9"]), reason: "F19 is outside [0, F9]" },
-		{ name: "part above whole", base: VALID.share[0].spec, mutate: operands(["F9", "F8"]), reason: "F9 is outside [0, F8]" },
-		{ name: "stray context", base: VALID.share[0].spec, mutate: (row) => ({ ...row, context: "x" }), reason: "share rows carry no context" },
-	],
-	ratio: [
-		...generic(VALID.ratio[0].spec, ["F10"]),
-		{ name: "affine units", base: VALID.ratio[0].spec, mutate: operands(["F13", "F14"]), reason: "ratio refuses affine" },
-		{ name: "divides by zero", base: VALID.ratio[0].spec, mutate: operands(["F10", "F15"]), reason: "denominator F15 is zero" },
-		{ name: "stray context", base: VALID.ratio[0].spec, mutate: (row) => ({ ...row, context: { target: "km" } }), reason: "ratio rows carry no context" },
-	],
-	convert: [
-		...generic(VALID.convert[0].spec, ["F12", "F1"]),
-		{ name: "no context", base: VALID.convert[0].spec, mutate: (row) => ({ ...row, context: null }), reason: "convert rows carry a context object" },
-		{ name: "empty target", base: VALID.convert[0].spec, mutate: (row) => ({ ...row, context: { target: "" } }), reason: "carries its target in context.target" },
-		{ name: "alias target", base: VALID.convert[0].spec, mutate: (row) => ({ ...relabel(row, "kilometre")[0], context: { target: "kilometre" } }), reason: 'context.target "kilometre" is not canonical' },
-		{ name: "currency target", base: VALID.convert[0].spec, mutate: (row) => ({ ...row, context: { target: "USD" } }), reason: "no table conversion to USD (a currency)" },
-		{ name: "no factor to target", base: VALID.convert[0].spec, mutate: (row) => ({ ...row, context: { target: "person" } }), reason: 'F12 in "m" has no table conversion to person' },
-		{ name: "closed context", base: VALID.convert[0].spec, mutate: (row) => ({ ...row, context: { target: "km", extra: true } }), reason: "exactly target" },
-	],
-	expr: [
-		...generic(VALID.expr[0].spec, ["F3", "F4", "F5"], "do not match operands", "do not match operands F999, F4"),
-		{ name: "formula id mismatch", base: VALID.expr[0].spec, mutate: (row) => ({ ...row, formula: "F3 - F99" }), reason: "do not match operands" },
-		{ name: "parse error", base: VALID.expr[0].spec, mutate: (row) => ({ ...row, formula: "F3 -" }), reason: "the expression ends early" },
-		{ name: "divides by zero", base: VALID.expr[0].spec, mutate: (row) => ({ ...row, formula: "F3 / (F4 - F4)" }), reason: "the expression divides by zero" },
-		{ name: "uninferable unit", base: VALID.expr[0].spec, mutate: (row) => ({ ...row, formula: "F3 + F4" }), reason: "adding % values" },
-		{ name: "affine sum", base: VALID.expr[0].spec, mutate: (row) => ({ ...row, formula: "F13 + F14", operands: ["F13", "F14"] }), reason: "adding affine (temperature)" },
-		{ name: "stray context", base: VALID.expr[0].spec, mutate: (row) => ({ ...row, context: { target: "km" } }), reason: "expr rows carry no context" },
-		{ name: "undated rate", base: VALID.expr[0].spec, mutate: (row, book) => {
-			const rate = book.rows.find((r) => r.fact_id === "F3")
-			if (!rate) throw Error("fixture rate missing")
-			rate.unit = "USD/EUR"
-			return { ...row, formula: "F3 * F4" }
-		}, reason: "dated valid_at" },
-	],
-}
-
-/** Review r6 HIGH: one id twice is never disjoint shares; expr repeats F1 inside its formula and stores the id set. */
-const REPEATED: Record<string, Spec> = {
-	sum: { ...PCT_SUM, operands: ["F3", "F3"] },
-	diff: { op: "diff", operands: ["F3", "F3"], unit: "%p" },
-	growth: { op: "growth", from: "F6", to: "F6", unit: "%" },
-	share: { op: "share", part: "F9", whole: "F9", unit: "%" },
-	ratio: { op: "ratio", num: "F10", den: "F10", unit: null },
-	convert: { op: "convert", operands: ["F12", "F12"], to: "km" },
-	expr: { op: "expr", formula: "F1 * F1 / F2", unit: "m" },
-}
-
-function rowOf(result: { row?: Row; error?: string; detail?: string }): Row {
-	if (!result.row) throw new Error(`expected a row, got ${result.error}: ${result.detail}`)
-	return result.row
-}
-
-/** The row relabeled to `unit`; when the operation persists a context, a second variant rewrites that context too. */
-function relabel(row: Row, unit: string | null): Row[] {
-	const shown = display(row.value, unit)
-	const render = row.operation === "convert" ? `${shown} ${String(row.render).slice(String(row.render).indexOf("("))}` : shown
-	const plain = { ...row, unit, raw: render, render }
-	const context = row.context as Row
-	if (row.operation === "convert") return [plain, { ...plain, context: { ...context, target: unit } }]
-	if (row.operation === "sum") return [plain, { ...plain, context: { ...context, reference: `relabeled ${unit}` } }]
-	return [plain]
-}
 
-const OPS = Object.keys(OPERATION_RULES)
 
 test("the case tables cover exactly the registry's operations, which are the ledger schema's operations", () => {
 	expect([...OPS].sort()).toEqual([...OPERATIONS].sort())

package/dist/skills/ulw-research/scripts/fidelity-claims.mjs

@@ -14,6 +14,7 @@
 import { CLAIM_ATTRIBUTE, CLAIM_KINDS, claimSatisfied, unmarkedKinds, unmarkedRequires } from "./claim-kinds.mjs"
 import { proseSentences } from "./fidelity-binding.mjs"
 import { clip } from "./fidelity-trace.mjs"
+import { isClaimSegment } from "./sources-citation.mjs"
 import { proseText } from "./html-lite.mjs"
 
 const marked = (node) => node.attrs?.[CLAIM_ATTRIBUTE] !== undefined
@@ -63,7 +64,7 @@ export function claimChecks(ctx, rows, provenanceOf, flag) {
 		const id = fact.attrs["data-fact"]
 		if (!nearest) {
 			const need = unmarkedRequires(rows.get(id))
-			const mark = need && `{{${CLAIM_KINDS[need].prefix}:${id}}} (${CLAIM_ATTRIBUTE}="${need}")`
+			const mark = need && `{{${CLAIM_KINDS[need].prefix}:${id}:${rows.get(id).label}}} (${CLAIM_ATTRIBUTE}="${need}")`
 			if (need) flag("claim_kind_mismatch", fact, `${id} is a ${rows.get(id).kind} row cited with no mark; an unmarked numeral reads as a fact, so mark it ${mark}`)
 			continue
 		}
@@ -77,8 +78,8 @@ export function claimChecks(ctx, rows, provenanceOf, flag) {
 		flag(entry.defect, fact, `${row.fact_id} is marked ${name}, but it is a ${row.kind} row${source}`)
 	}
 	for (const block of proseSentences(ctx)) {
-		if (block.kind === "sources" || block.kind === "toc") continue
-		for (const sentence of block.sentences) {
+		if (block.kind === "toc") continue
+		for (const sentence of block.kind === "sources" ? block.sentences.filter((s) => isClaimSegment(s.text)) : block.sentences) {
 			for (const name of unmarkedKinds(sentence.text)) {
 				const covered = sentence.facts.length > 0 ? sentence.facts.every((fact) => nearestKind(fact.node) === name) : nearestKind(block.owner) === name
 				if (covered) continue

package/dist/skills/ulw-research/scripts/fidelity-csv.mjs

@@ -0,0 +1,32 @@
+// Read fact export CSV records, including quoted commas, escaped quotes and newlines.
+import { existsSync, readFileSync } from "node:fs"
+
+export function readCsv(path) {
+	if (!existsSync(path)) return null
+	const text = readFileSync(path, "utf8")
+	const records = []
+	let cells = []
+	let cell = ""
+	let quoted = false
+	for (let i = 0; i <= text.length; i++) {
+		const char = text[i]
+		if (char === '"') {
+			if (quoted && text[i + 1] === '"') {
+				cell += '"'
+				i++
+			} else quoted = !quoted
+		} else if (!quoted && (char === "," || char === "\n" || char === undefined)) {
+			cells.push(cell.trim())
+			cell = ""
+			if (char !== ",") {
+				if (cells.some((value) => value !== "")) records.push(cells)
+				cells = []
+			}
+		} else if (char !== undefined) cell += char
+	}
+	if (quoted) return null
+	const [head = [], ...rows] = records
+	const [id, value, unit] = ["fact_id", "plot_value", "unit"].map((name) => head.indexOf(name))
+	if (id < 0 || value < 0 || unit < 0 || rows.length === 0) return null
+	return rows.map((c) => ({ fact_id: c[id], plot_value: c[value], unit: c[unit] ?? "" }))
+}

package/dist/skills/ulw-research/scripts/fidelity-lexicon.mjs

@@ -4,7 +4,7 @@
 // causality_added, qualifier_dropped (six-token window around the fact span; a :q rendering puts
 // the qualifier inside the span), scope_widened_warn, and the acronym-aware name_outside_quote.
 // The hedge-position heuristic never yields a code; it only sets force_strong for the meaning
-// verifier, as do name_outside_quote and scope_widened_warn. Latin terms match whole words (terms
+// verifier; name_outside_quote and scope_widened_warn also emit minor defects. Latin terms match whole words (terms
 // of four or more letters also match their inflections); Korean terms match as substrings, single
 // syllables as tokens. No model, no IO. Plain Node ESM; Korean strings are \u escapes.
 

package/dist/skills/ulw-research/scripts/fidelity-originals.mjs

@@ -0,0 +1,161 @@
+// Check displayed conversion originals against their operands, not the mutable render field.
+import { sameValue, unitKey } from "./fidelity-binding.mjs"
+import { proseText } from "./html-lite.mjs"
+import { parseNumeral } from "./numerals.mjs"
+import { normalizeText } from "./text-normalize.mjs"
+import { display } from "./unit-precision.mjs"
+import { dimensionOf } from "./units.mjs"
+
+const DERIVED = new Set(["converted", "derived"])
+/**
+ * The one bracket grammar of the skill. After NFKC (fullwidth parentheses and square brackets fold
+ * to ASCII), an original is a () [] 【】 「」 or 〔〕 group. Inside a derived or converted element every
+ * group is an original, never prose; a dash separator is not an original.
+ */
+const PAIRS = [["(", ")"], ["[", "]"], ["\u3010", "\u3011"], ["\u300C", "\u300D"], ["\u3014", "\u3015"]]
+const [OPEN, CLOSE] = [PAIRS.map((pair) => pair[0]).join(""), PAIRS.map((pair) => pair[1]).join("")]
+const inClass = (chars) => chars.replace(/[\\\]\[^-]/g, "\\$&")
+const literal = (chars) => chars.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+const ANY = inClass(OPEN + CLOSE)
+const GROUP = new RegExp(PAIRS.map(([open, close]) => `${literal(open)}([^${ANY}]*)${literal(close)}`).join("|"), "gu")
+const BRACKET = new RegExp(`[${ANY}]`, "u")
+const folded = (text) => String(text).normalize("NFKC")
+const innerOf = (match) => match.slice(1).find((part) => part !== undefined)
+const mismatch = (message) => ["value_mismatch", message, "original"]
+
+const halfFits = (row, half) => {
+	const expected = normalizeText(folded(display(String(row.value), row.unit ?? null)))
+	const text = normalizeText(half)
+	return text === expected || (text.endsWith(` ${expected}`) && !/\d/.test(text.slice(0, -expected.length)))
+}
+
+/** The converted half (the text outside the originals) equals display(row.value, row.unit), rebuilt from the row. */
+export function convertedHalfFits(row, shown) {
+	if (!DERIVED.has(row.kind) || row.value === null || row.value === undefined) return false
+	return halfFits(row, folded(shown).replace(GROUP, ""))
+}
+
+/** A second number outside the value verify reads and its originals ("320,000 mm - 999 m"). */
+function strayNumber(row, half) {
+	if (row.value === null || row.value === undefined || halfFits(row, half)) return null
+	const read = parseNumeral(half)
+	if (!read || !sameValue(read.value, row.value)) return null
+	const rest = half.slice(0, read.span[0]) + half.slice(read.span[1])
+	return /\d/.test(row.unit ? rest.split(row.unit).join("") : rest) ? mismatch(`"${half.trim()}" carries a number besides the value and its originals`) : null
+}
+
+/** `valueMode`: the element shows the bare value ({{F:x:value}}), so no original is due. */
+export function originalProblem(row, shown, rows, valueMode = false) {
+	if (!DERIVED.has(row.kind)) return null
+	const text = folded(shown)
+	const groups = [...text.matchAll(GROUP)]
+	const half = text.replace(GROUP, "")
+	if (BRACKET.test(half)) return mismatch("original brackets are malformed or nested")
+	const operands = (row.derived_from ?? []).map((id) => rows.get(id))
+	for (const [index, match] of groups.entries()) {
+		const [inner, operand] = [innerOf(match), operands[index]]
+		const parsed = parseNumeral(inner)
+		if (!operand) return mismatch(`original "${inner}" has no operand of ${row.fact_id}`)
+		if (!parsed || !sameValue(parsed.value, operand.value)) return mismatch(`original "${inner}" differs from operand ${operand.fact_id}`)
+		if (unitKey(parsed.unitRaw ?? "") !== unitKey(operand.unit ?? "")) return ["unit_mismatch", `original "${inner}" is not in ${operand.unit}`, "original"]
+		const expected = normalizeText(folded(display(operand.value, operand.unit ?? null)))
+		if (normalizeText(inner) !== expected) return mismatch(`original "${inner}" differs from "${expected}"`)
+	}
+	if (groups.length > 0 && !/\d/.test(text.slice(0, groups[0].index))) return mismatch(`original "${innerOf(groups[0])}" precedes the value`)
+	if (row.kind === "converted" && !valueMode && /\d/.test(half) && groups.length < operands.length) return mismatch(`the original of ${row.derived_from[groups.length]} is missing after the value`)
+	return strayNumber(row, half)
+}
+
+/** Stands for a filled element or another fill-map value in the text after a fill site. */
+const FILLED = "\uFFFC"
+/** After a fill site the grammar also reads the brackets an element never carries as originals. */
+const FOLLOW = [...PAIRS, ["\u300E", "\u300F"], ["\u300A", "\u300B"], ["\u3008", "\u3009"], ["\u27E8", "\u27E9"]]
+const dimension = (unit) => dimensionOf(String(unit).replace(/-e\d+$/u, "")) ?? unitKey(unit)
+
+/** What the text after a fill site opens: a bracket group's content, or the clause after a separator (`open`); else null. */
+function openedGroup(text) {
+	const rest = folded(text).trimStart()
+	const pair = FOLLOW.find(([open]) => rest.startsWith(open))
+	const close = pair ? rest.indexOf(pair[1], 1) : -1
+	if (pair) return { group: rest.slice(1, close === -1 ? undefined : close).trim(), open: false }
+	return /^[-\u2013\u2014/]/u.test(rest) ? { group: rest.slice(1).split(/[,;:!?)\]]|\.(?!\d)/u)[0].trim(), open: true } : null
+}
+
+/**
+ * Whether the text right after a fill site of `row` opens another original: a bracket group or a
+ * separator clause that is exactly a numeral with a unit of the row's or an operand's dimension (a
+ * separator clause may end in a glued particle, as Korean writes "- 999 m\uC774\uB2E4").
+ * A filled element, a fill-map value (`fills`), a placeholder, a unitless number (a year, a
+ * footnote) and prose with digits are not originals; untraceable_number still reads a stray number.
+ */
+export const followsOriginal = (row, rows, fills = []) => (text) => {
+	if (!DERIVED.has(row?.kind)) return false
+	const after = [...fills].filter(Boolean).sort((a, b) => b.length - a.length).reduce((cur, fill) => cur.split(fill).join(FILLED), String(text))
+	const { group, open } = openedGroup(after) ?? { group: "" }
+	if (!group || group.includes(FILLED) || group.includes("{{")) return false
+	const units = [row.unit, ...(row.derived_from ?? []).map((id) => rows.get(id)?.unit)].filter(Boolean)
+	return [group, ...(open ? [group.replace(/[\uAC00-\uD7A3]+$/u, "").trim()] : [])].some((body) => {
+		const read = parseNumeral(body, 0)
+		return Boolean(read?.unitRaw) && read.span[0] === 0 && read.span[1] === body.length && units.some((unit) => dimension(unit) === dimension(read.unitRaw))
+	})
+}
+
+/** The prose after `node` in its parent, each filled element (data-fact) read as one FILLED mark. */
+export const textAfter = (node) => {
+	const siblings = node.parent?.children.slice(node.parent.children.indexOf(node) + 1) ?? []
+	return proseText({ children: siblings.map((child) => (child.attrs?.["data-fact"] === undefined ? child : { tag: "#text", text: FILLED })) })
+}
+
+const SPACE = "[\\s\\u3000]"
+const DIGIT = "[0-9\\uFF10-\\uFF19]"
+/** Each character with the fullwidth form NFKC folds onto it. */
+const wide = (chars) => [...chars].map((ch) => ch + (/[!-~]/.test(ch) ? String.fromCharCode(ch.charCodeAt(0) + 0xfee0) : "")).join("")
+const [WIDE_OPEN, WIDE_CLOSE] = [inClass(wide(OPEN)), inClass(wide(CLOSE))]
+
+/** A pattern reading `rendered` modulo the bracket grammar: NFKC fullwidth forms, bracket style, spacing around brackets. */
+function renderPattern(rendered) {
+	const text = folded(rendered).trim()
+	let body = ""
+	for (let at = 0; at < text.length; at += 1) {
+		const ch = text[at]
+		const beside = (OPEN + CLOSE).includes(text.slice(at).trimStart()[0]) || OPEN.includes(text[at - 1])
+		if (/\s/.test(ch)) body += beside ? "" : `${SPACE}+`
+		else if (OPEN.includes(ch)) body += `${SPACE}*([${WIDE_OPEN}])${SPACE}*`
+		else if (CLOSE.includes(ch)) body += `${SPACE}*([${WIDE_CLOSE}])`
+		else body += `[${inClass(wide(ch))}]`
+	}
+	// A digit may not run into a render's leading or trailing digit ("1,320 m" holds no "320 m"); a bracket ends the render.
+	return new RegExp(`${/^\d/.test(text) ? `(?<!${DIGIT})` : ""}${body}${/\d$/.test(text) ? `(?!${DIGIT})` : ""}`, "gu")
+}
+
+const pairIndex = (ch, side) => [...side].findIndex((open) => open === folded(ch))
+/** [start, end) of `rendered` in `text` from `from` under the bracket grammar, not followed by another original (`follows`); or null. */
+export function findRender(text, rendered, from = 0, follows = () => false) {
+	const pattern = renderPattern(rendered)
+	pattern.lastIndex = from
+	for (let match = pattern.exec(text); match; match = pattern.exec(text)) {
+		const marks = match.slice(1)
+		const paired = marks.every((mark, i) => i % 2 === 1 || pairIndex(mark, OPEN) === pairIndex(marks[i + 1] ?? "", CLOSE))
+		const end = match.index + match[0].length
+		if (paired && !follows(text.slice(end))) return [match.index, end]
+		pattern.lastIndex = match.index + 1
+	}
+	return null
+}
+
+/** Where a stale fill-map entry's text sits: derived and converted renders are read under the bracket grammar. */
+export const renderLocator = (rows, fillMap) => (entry, text, from) => {
+	const row = rows.get(entry.fact_id)
+	if (DERIVED.has(row?.kind)) return findRender(text, entry.rendered, from, followsOriginal(row, rows, (fillMap ?? []).map((other) => other.rendered)))
+	const hit = text.indexOf(entry.rendered, from)
+	return hit === -1 ? null : [hit, hit + entry.rendered.length]
+}
+
+/** Null when a stale derived render is still in the report; "original" when only its converted half is; "gone" otherwise. */
+export function staleRender(row, rendered, text, follows) {
+	if (findRender(text, rendered, 0, follows) !== null) return null
+	const half = folded(rendered).replace(GROUP, "").trim()
+	return half !== "" && /\d/.test(half) && findRender(text, half) !== null ? "original" : "gone"
+}
+
+export const isDerivedRow = (row) => DERIVED.has(row?.kind)