oh-my-opencode 5.1.48 → 5.1.54

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

@@ -0,0 +1,241 @@
+import { describe, expect, test } from "bun:test"
+import { display, recompute } from "../fact-derive.mjs"
+import { derive } from "./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"
+
+// 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)
+export { Row, Ledger, Spec, HASH, measured, ledger, PCT_SUM, VALID, PRECISION, RELABELS, Mutation, generic, repeatFirst, operands, MALFORMED, REPEATED, rowOf, relabel, OPS }

package/dist/skills/ulw-research/scripts/tests/fidelity-values-support.ts

@@ -0,0 +1,30 @@
+/// <reference types="bun-types" />
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { valueChecks } from "../fidelity-values.mjs"
+import { buildContext } from "../gates-static.mjs"
+import { parseHtml } from "../html-lite.mjs"
+
+export type Defect = { code: string; severity: string; selector: string; line: number; message: string; hint: string }
+export type Row = Record<string, unknown> & { fact_id: string }
+type Ledger = { schemaVersion: number; rows: Row[]; events: unknown[] }
+type FillEntry = { fact_id: string; rendered: string; selector?: string }
+type Options = { ledger?: Ledger; fillMap?: FillEntry[] | null; sourcesDir?: string | null; baseDir?: string; recompute?: (ledger: object, row: object) => { ok: boolean }; asOf?: string }
+
+const FIX = join(import.meta.dir, "fixtures", "fidelity")
+export const SOURCES = join(FIX, "sources")
+export const LEDGER: Ledger = JSON.parse(readFileSync(join(FIX, "ledger-verify.json"), "utf8"))
+
+export function ledgerWith(id: string, patch: Record<string, unknown>): Ledger {
+	const copy = structuredClone(LEDGER)
+	copy.rows = copy.rows.map((row) => (row.fact_id === id ? { ...row, ...patch } : row))
+	return copy
+}
+
+export function run(body: string, options: Options = {}): Defect[] {
+	const html = /<h2/.test(body) ? body : `<h2>Findings</h2>\n${body}`
+	const ctx = buildContext(parseHtml(html), { baseDir: options.baseDir ?? FIX })
+	const sourcesDir = options.sourcesDir === undefined ? SOURCES : options.sourcesDir
+	return valueChecks(ctx, options.ledger ?? LEDGER, options.fillMap ?? null, sourcesDir, options) as Defect[]
+}

package/dist/skills/ulw-research/scripts/tests/fixtures/conversion-probe.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+<body>
+<p>USD 4.2<sup>2</sup> billion</p>
+<p>27.3<sup><a href="#fn1">1</a></sup> percent</p>
+<p>km<sup>2</sup>; 10<sup>9</sup> kWh</p>
+<p><span>1</span><span>,</span><span>234.5</span></p>
+<p>1 234 567</p>
+<p><del>1,200</del> <ins>1,250</ins></p>
+<p><time datetime="2026-10-01T09:00:00Z">1 Oct</time></p>
+<p><span style="display:none">99.9</span></p>
+<table><tr><th>Total<sup>2</sup></th><td>12,345</td><td>15,678</td></tr></table>
+</body>
+</html>

package/dist/skills/ulw-research/scripts/tests/fixtures/sources-shapes.html

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Reference shapes</title></head>
+<body>
+<h2>Findings</h2>
+<p>The bridge span is reported in the cited annual report [S1].</p>
+<h2>Sources</h2>
+<p class="note">Publication cutoff and access date: October 25, 2026. Every linked source was read directly.</p>
+<h3>2024</h3>
+<ol>
+<li>Smith, J. (2024). Annual report. https://example.com/annual-2024</li>
+<li>Harbor Authority, Yearbook 2024, pp. 12-15, https://example.com/yearbook</li>
+<li>Bridge Review, Vol. 2024/1, No. 3, https://example.com/review. Accessed 25 October 2026.</li>
+<li>[S1] Annual report 2024, <a href="https://example.com/report">example.com/report</a></li>
+</ol>
+<p>Annual report 2024, https://example.com/report</p>
+<p>[S2] City statistics office, 2025 release, https://example.com/stats<br>Last updated 2026-03-24.</p>
+<dl><dt>[S3] Transit survey</dt><dd>Survey 2025, https://example.com/survey</dd><dd>Accessed 2026-10-25.</dd></dl>
+<table><thead><tr><th>Source</th><th>What it contains</th><th>Reliability</th><th>Access date</th></tr></thead>
+<tbody><tr><td><a href="https://example.com/a">Agency report 2024</a></td><td>Span tables, 2019-2024</td><td>Primary</td><td>2026-10-25</td></tr></tbody></table>
+</body></html>

package/dist/skills/ulw-research/scripts/tests/numeral-classes.ts

@@ -0,0 +1,196 @@
+// Row tables for the Sources numeral classes (lead order, review round 5 #11302): every form of a
+// class with the class the Sources predicate must give each digit run in it. A string expectation
+// applies to every digit run of the input; an array lists them in order. Consumed by
+// sources-citation.test.ts. Korean text is \u escaped.
+
+export type NumeralKind = "numeral" | "name" | "date" | "citation-field"
+export type ClassRow = { input: string; expected: NumeralKind | NumeralKind[] }
+
+// Class 1: numeral tokenization vs glued letters. Every unit, multiplier, percent, and currency
+// token of units.mjs (tokens and aliases) and of the numerals.mjs UNIT pattern, written after the
+// number: glued, spaced, glued behind a Hangul word, glued behind a Latin word, with a Korean
+// particle, and behind a Hangul word with a particle.
+const LATIN_UNITS = [
+	"mm", "millimeter", "millimeters", "millimetre", "cm", "centimeter", "m", "meter", "meters", "metre", "km", "kilometer", "kilometers",
+	"g", "gram", "grams", "kg", "kilogram", "kilograms", "t", "ton", "tons", "tonne", "tonnes",
+	"ms", "millisecond", "milliseconds", "s", "sec", "secs", "second", "seconds", "min", "mins", "minute", "minutes", "h", "hr", "hrs", "hour", "hours",
+	"day", "days", "week", "weeks", "month", "months", "mo", "year", "years", "yr", "yrs",
+	"B", "byte", "bytes", "KB", "MB", "GB", "TB", "kb", "mb", "gb", "tb", "C", "F", "celsius", "fahrenheit",
+	"percent", "pct", "permille", "pp", "bp", "bps",
+	"x", "times", "k", "K", "thousand", "M", "mn", "million", "b", "bn", "billion", "T", "trillion",
+	"person", "persons", "people", "users", "employees", "engineers", "tokens", "requests", "stars", "downloads", "customers", "case", "cases",
+	"KRW", "won", "USD", "usd", "dollar", "dollars", "EUR", "eur", "euro", "euros", "JPY", "yen", "GBP", "pound", "pounds",
+]
+const SYMBOL_UNITS = ["%", "%p", "%pt", "\u2030", "\u00D7", "\u00B0C", "\u00B0F", "\u2103", "\u2109", "$", "\u20AC", "\u00A3", "\u00A5", "\u20A9"]
+const HANGUL_UNITS = [
+	"\uBC00\uB9AC\uBBF8\uD130", "\uC13C\uD2F0\uBBF8\uD130", "\uBBF8\uD130", "\uD0AC\uB85C\uBBF8\uD130", "\uADF8\uB7A8", "\uD0AC\uB85C\uADF8\uB7A8", "\uD1A4", "\uBC00\uB9AC\uCD08", "\uCD08", "\uBD84", "\uC2DC\uAC04", "\uC77C", "\uC8FC", "\uAC1C\uC6D4", "\uB144",
+	"\uBC14\uC774\uD2B8", "\uD0AC\uB85C\uBC14\uC774\uD2B8", "\uBA54\uAC00\uBC14\uC774\uD2B8", "\uAE30\uAC00\uBC14\uC774\uD2B8", "\uD14C\uB77C\uBC14\uC774\uD2B8",
+	"\uD37C\uC13C\uD2B8", "\uD504\uB85C", "\uD37C\uBC00", "\uD37C\uC13C\uD2B8\uD3EC\uC778\uD2B8", "\uBC30", "\uCC9C", "\uB9CC", "\uBC31\uB9CC", "\uC5B5", "\uC2ED\uC5B5", "\uC870",
+	"\uBA85", "\uAC74", "\uAC1C", "\uD68C", "\uBC88", "\uC6D0", "\uCC9C\uC6D0", "\uB9CC\uC6D0", "\uC5B5\uC6D0", "\uC870\uC6D0", "\uB2EC\uB7EC", "\uC720\uB85C", "\uC5D4", "\uD30C\uC6B4\uB4DC",
+]
+const KO_WORD = "\uB9E4\uCD9C"
+const LATIN_WORD = "rate"
+
+const unitRows = (unit: string, kind: "latin" | "symbol" | "hangul"): ClassRow[] => {
+	const particle = kind === "hangul" ? "\uC774" : "\uB85C"
+	return [
+		{ input: `5${unit}`, expected: "numeral" },
+		{ input: `5 ${unit}`, expected: "numeral" },
+		{ input: `${KO_WORD}5${unit}`, expected: "numeral" },
+		// Latin letters on both sides of a digit run make an identifier ("W3C"); a symbol or Hangul unit keeps it a measure.
+		{ input: `${LATIN_WORD}5${unit}`, expected: kind === "latin" ? "name" : "numeral" },
+		{ input: `5${unit}${particle}`, expected: "numeral" },
+		{ input: `${KO_WORD}5${unit}${particle}`, expected: "numeral" },
+	]
+}
+
+// Written before the number: currency symbols and codes, and a standalone multiplier x.
+const PREFIXES = ["$", "US$", "\u20AC", "\u00A3", "\u00A5", "\u20A9", "USD", "KRW", "EUR", "JPY", "GBP"]
+const prefixRows = (prefix: string): ClassRow[] => [
+	{ input: `${prefix}5`, expected: "numeral" },
+	{ input: `${prefix}5.5`, expected: "numeral" },
+	{ input: `${KO_WORD}${prefix}5`, expected: "numeral" },
+	{ input: `${prefix}5bn`, expected: "numeral" },
+]
+
+export const GLUED_LETTER_ROWS: ClassRow[] = [
+	...LATIN_UNITS.flatMap((unit) => unitRows(unit, "latin")),
+	...SYMBOL_UNITS.flatMap((unit) => unitRows(unit, "symbol")),
+	...HANGUL_UNITS.flatMap((unit) => unitRows(unit, "hangul")),
+	...PREFIXES.flatMap(prefixRows),
+	// Multipliers on the left and on the right, with decimals.
+	{ input: "x3", expected: "numeral" },
+	{ input: "x1.5 faster", expected: "numeral" },
+	{ input: "(x3)", expected: "numeral" },
+	{ input: "\uC18D\uB3C4x3", expected: "numeral" },
+	{ input: "\u00D73", expected: "numeral" },
+	{ input: "3.5x", expected: "numeral" },
+	{ input: "1.2bn", expected: "numeral" },
+	{ input: "5.4T", expected: "numeral" },
+	{ input: "3.5k", expected: "numeral" },
+	{ input: "1M+", expected: "numeral" },
+	{ input: "2.5\uBC30", expected: "numeral" },
+	{ input: "1,200\uBA85", expected: "numeral" },
+	{ input: "3\uC5B5 2,000\uB9CC\uC6D0", expected: "numeral" },
+	// Glued letters that are not a unit, multiplier, percent, or currency: a name.
+	{ input: "abc123", expected: "name" },
+	{ input: "W3C", expected: "name" },
+	{ input: "eb2b", expected: "name" },
+	{ input: "a75f4d93ef", expected: "name" },
+	{ input: "424B4", expected: "name" },
+	{ input: "1H25", expected: "name" },
+	{ input: "3D", expected: "name" },
+	{ input: "21st", expected: "name" },
+	{ input: "KOSPI200", expected: "name" },
+	{ input: "Base44", expected: "name" },
+	{ input: "H100", expected: "name" },
+	{ input: "mp3", expected: "name" },
+	{ input: "[w1:x02]", expected: ["name", "name"] },
+	{ input: "x02", expected: "name" },
+	{ input: "rate5M", expected: "name" },
+	{ input: "\uCF54\uB4DCabc123", expected: "name" },
+	// Korean ordinals are names: the prefix je, the suffix jjae, and the counter cha.
+	{ input: "\uC81C3\uD68C", expected: "name" },
+	{ input: "\uC81C3\uC790", expected: "name" },
+	{ input: "\uC81C2\uCC28", expected: "name" },
+	{ input: "3\uBC88\uC9F8", expected: "name" },
+	{ input: "2\uCC28 \uBCF4\uB3C4", expected: "name" },
+	// A word glued in front of a measure keeps it a numeral (the round-4 receipt rows).
+	{ input: "\uB9E4\uCD9C40% \uC99D\uAC00.", expected: "numeral" },
+	{ input: "\uC804\uB144\uB300\uBE4430%", expected: "numeral" },
+	{ input: "\uC57D300\uBA85", expected: "numeral" },
+	{ input: "Churn rate40%", expected: "numeral" },
+	{ input: "x3 faster.", expected: "numeral" },
+	{ input: "Grew 5mn users.", expected: "numeral" },
+	{ input: "Up 40pct.", expected: "numeral" },
+	{ input: "5yrs of data.", expected: "numeral" },
+]
+
+// Class 2: date, version, and name shapes: every slashed, dotted, and dashed form.
+export const SHAPE_ROWS: ClassRow[] = [
+	// Month/day, day/month/year, and full dates.
+	{ input: "10/26", expected: "date" },
+	{ input: "1/31", expected: "date" },
+	{ input: "12/1", expected: "date" },
+	{ input: "(released 10/26)", expected: "date" },
+	{ input: "10/26 \uACF5\uAC1C", expected: "date" },
+	{ input: "26/10/2026", expected: "date" },
+	{ input: "10/26/2026", expected: "date" },
+	{ input: "26.10.2026", expected: "date" },
+	{ input: "26-10-2026", expected: "date" },
+	{ input: "2026-10-26", expected: "date" },
+	{ input: "2026/10/26", expected: "date" },
+	{ input: "2026.10.26", expected: "date" },
+	{ input: "2026.10.26.", expected: "date" },
+	{ input: "2026. 10. 26.", expected: "date" },
+	{ input: "2026-10", expected: "date" },
+	{ input: "2026.10", expected: "date" },
+	{ input: "26.10.26", expected: "date" },
+	{ input: "Oct 26", expected: "date" },
+	{ input: "26 Oct", expected: "date" },
+	{ input: "October 26, 2026", expected: "date" },
+	{ input: "26 October 2026", expected: "date" },
+	{ input: "2026\uB144 10\uC6D4 26\uC77C", expected: "date" },
+	{ input: "10\uC6D4 26\uC77C", expected: "date" },
+	{ input: "2026", expected: "date" },
+	{ input: "2026\uB144", expected: "date" },
+	{ input: "2025\uB144 3\uBD84\uAE30", expected: "date" },
+	{ input: "3\uBD84\uAE30", expected: "date" },
+	{ input: "2026\uB144 1\uBD84\uAE30", expected: "date" },
+		// Year ranges.
+	{ input: "2019-2023", expected: "date" },
+	{ input: "2019~2023", expected: "date" },
+	{ input: "2019\u20132023", expected: "date" },
+	{ input: "2019 \u2013 2023", expected: "date" },
+	{ input: "2025\u20132026\uB144", expected: "date" },
+	{ input: "2019~2023\uB144", expected: "date" },
+	// Not a date: a slashed pair outside month/day, and a day count.
+	{ input: "13/45", expected: ["numeral", "numeral"] },
+	{ input: "30 days", expected: "numeral" },
+	{ input: "30\uC77C\uAC04", expected: "numeral" },
+	// Versions and decimals: a dotted run with a segment that is not three digits is a version name;
+	// one dot is a decimal; three-digit period groups are a European grouping.
+	{ input: "1.2", expected: "numeral" },
+	{ input: "Llama 3.1", expected: "numeral" },
+	{ input: "v1.2", expected: "name" },
+	{ input: "1.2.3", expected: "name" },
+	{ input: "0.30.14", expected: "name" },
+	{ input: "v2.3.1", expected: "name" },
+	{ input: "(3.1.1)", expected: "name" },
+	{ input: "1.234.567", expected: "numeral" },
+	{ input: "1.234.567\uBA85", expected: "numeral" },
+	{ input: "1.234,5", expected: "numeral" },
+	{ input: "1,234.5", expected: "numeral" },
+	{ input: "1,234,567", expected: "numeral" },
+	{ input: "1.234", expected: "numeral" },
+	// Codes: a filing code whose letter is a multiplier stays a numeral; other codes are names.
+	{ input: "10-K", expected: "numeral" },
+	{ input: "8-K", expected: "numeral" },
+	{ input: "10-Q", expected: "name" },
+	{ input: "S-1", expected: "name" },
+	{ input: "#123", expected: "name" },
+	{ input: "#6674\u2013#7906", expected: ["name", "name"] },
+	{ input: "GPT-4", expected: "name" },
+	{ input: "H.15", expected: "name" },
+	{ input: "Q3", expected: "name" },
+	{ input: "FY27", expected: "name" },
+	{ input: "Q3-2024", expected: ["name", "date"] },
+	{ input: "H1 2026", expected: ["name", "date"] },
+	{ input: "2024-Q3-F1", expected: ["date", "name", "name"] },
+	{ input: "DGS10/DGS30", expected: ["name", "name"] },
+	// Citation fields: markers, identifiers, and containers.
+	{ input: "pp. 12-15", expected: "citation-field" },
+	{ input: "p. 7", expected: "citation-field" },
+	{ input: "Vol. 2024/1", expected: "citation-field" },
+	{ input: "No. 3", expected: "citation-field" },
+	{ input: "3rd edition", expected: "citation-field" },
+	{ input: "45-52\uCABD", expected: "citation-field" },
+	{ input: "3\uAD8C 2\uD638", expected: "citation-field" },
+	{ input: "[S4]", expected: "citation-field" },
+	{ input: "DOI 10.1145/1571941.1572114", expected: "citation-field" },
+	{ input: "arXiv 2402.17753", expected: "citation-field" },
+	{ input: "ISBN 978-0-306-40615-7", expected: "citation-field" },
+	{ input: "https://example.com/2024/10/report-42", expected: "citation-field" },
+	{ input: "\"Sales fell 3.5% in Q2\"", expected: "citation-field" },
+	{ input: "\u300C\uC218\uCD9C 12% \uC99D\uAC00\u300D", expected: "citation-field" },
+]