oh-my-opencode 5.1.48 → 5.1.54

package/dist/skills/ulw-research/scripts/fact-fill.mjs

@@ -9,6 +9,7 @@ import { finalReading, rewriteParticle } from "./particles-ko.mjs"
 import { failureCount, markReplaced, sentenceKey } from "./fidelity-state.mjs"
 import { findPlaceholders, lead, qualifiedText, renderBlockquote, renderQuote, renderValueHtml, subSpan, valueParts } from "./placeholder.mjs"
 import { splitSentences } from "./sentence-split.mjs"
+import { CLAIM_KINDS } from "./claim-kinds.mjs"
 
 /** The output formats fill renders. */
 export const FILL_FORMATS = Object.freeze(["html", "md"])
@@ -24,7 +25,7 @@ function resolveValue(row, parsed, format) {
 	const { valueText, unitText } = valueParts(row)
 	const text = { full: row.raw, value: valueText, unit: unitText, q: qualifiedText(row) }[parsed.mode]
 	if (text === null) return { code: "quote_anchor_unresolved", message: `${row.fact_id} has qualifier ${row.qualifier}, but its quote holds no qualifier beside "${row.raw}"` }
-	return { row, parsed, visible: text, rendered: format === "html" ? renderValueHtml(row, text) : text }
+	return { row, parsed, visible: text, rendered: format === "html" ? renderValueHtml(row, text, { mode: parsed.mode, claimKind: parsed.claimKind ?? null }) : text }
 }
 
 function resolveQuote(row, parsed, format) {
@@ -33,17 +34,18 @@ function resolveQuote(row, parsed, format) {
 	if (selection === null) {
 		return { code: "quote_anchor_unresolved", message: `from "${parsed.from}" and to "${parsed.to}" must each occur exactly once in ${row.fact_id}'s quote, in that order` }
 	}
-	const rendered = renderQuote(row, parsed.selector, selection.text, format)
+	const rendered = renderQuote(row, parsed.selector, selection.text, format, parsed.claimKind)
 	return { row, parsed, visible: `[${row.source_id}]`, rendered, selector: parsed.selector, quote_span: [selection.start, selection.end] }
 }
 
 function resolve(found, rows, format) {
 	const { parsed } = found
-	if (parsed.error) return { code: "unresolved_placeholder", message: parsed.error }
+	if (parsed.error) return { code: "unresolved_placeholder", message: `${parsed.error}; for literal opening braces, write {{ instead of {{ (including in code spans)` }
 	const row = rows.get(parsed.id)
 	if (row === undefined) return { code: "unresolved_placeholder", message: `${parsed.id} is not in the fact ledger` }
 	if (row.status !== "active") return { code: "unresolved_placeholder", message: `${parsed.id} is ${row.status}; cite its replacement` }
 	if (row.label !== parsed.label) return { code: "pointer_label_mismatch", message: `${parsed.id} has label "${row.label}", not "${parsed.label}"` }
+	if (parsed.claimKind && !CLAIM_KINDS[parsed.claimKind].rowKinds.includes(row.kind)) return { code: CLAIM_KINDS[parsed.claimKind].defect, message: `${parsed.claimKind} does not accept a ${row.kind} row (${parsed.id})` }
 	return parsed.kind === "Q" ? resolveQuote(row, parsed, format) : resolveValue(row, parsed, format)
 }
 
@@ -146,7 +148,7 @@ function assemble(text, parts, context) {
 		flush(part.start)
 		const start = context.out.length
 		if (part.parsed) {
-			const extra = part.selector === undefined ? {} : { selector: part.selector, quote_span: part.quote_span }
+			const extra = { ...(part.selector === undefined ? {} : { selector: part.selector, quote_span: part.quote_span }), ...(part.parsed.claimKind ? { claimKind: part.parsed.claimKind } : {}), ...(part.parsed.mode === "value" ? { mode: "value" } : {}) }
 			context.fillMap.push({ token: part.token, fact_id: part.row.fact_id, start, end: start + part.rendered.length, rendered: part.rendered, ...extra })
 		} else if (part.rendered !== "") {
 			context.fillMap.push({ token: null, fact_id: part.source.fact_id, replaced: part.key, start, end: start + part.rendered.length, rendered: part.rendered })

package/dist/skills/ulw-research/scripts/fact-ledger-kinds.mjs

@@ -3,7 +3,6 @@
 // per-kind choices (id prefix, measured exact) from it, and the per-kind table in
 // references/fact-ledger-grammar.md is rendered from it (`node fact-ledger-kinds.mjs --render-grammar`).
 // Also the value primitives the schema shares. Pure functions with no IO; node: builtins only.
-
 import { isCliEntry } from "./entry-guard.mjs"
 import { canonicalUnit, inputScale, RuleError } from "./unit-algebra.mjs"
 import { metadataErrors } from "./unit-metadata.mjs"
@@ -15,7 +14,6 @@ export const DECIMAL = /^-?\d+(?:\.\d+)?$/
 const INTEGER = /^-?\d+$/
 const SHA256 = /^[0-9a-f]{64}$/
 const SOURCE_ID = /^S\d+$/
-
 export const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
 export const isString = (value) => typeof value === "string"
 export const isNonEmpty = (value) => typeof value === "string" && value.length > 0
@@ -48,6 +46,7 @@ export function locatorErrors(locator, at) {
 	const errors = []
 	if (!isObject(locator)) return errors
 	if (!isNonEmpty(locator.artifact)) errors.push(`${at}.artifact must be a non-empty string`)
+	if (locator.unit !== undefined && locator.unit !== "bytes") errors.push(`${at}.unit must be bytes`)
 	if (!(isCount(locator.char_start) && isCount(locator.char_end) && locator.char_start <= locator.char_end)) errors.push(`${at}.char_start/char_end must be integers with start <= end`)
 	for (const key of ["page", "line"]) {
 		if (locator[key] !== undefined && !(Number.isInteger(locator[key]) && locator[key] >= 1)) errors.push(`${at}.${key} must be an integer >= 1`)
@@ -87,6 +86,7 @@ export const RULES = Object.freeze({
 	rational_or_null: { cell: "rational or null", says: "null or { num: integer string, den: positive integer string }", test: orNull(isRational) },
 	by_derive: { cell: "reduced rational", says: "a reduced { num: integer string, den: positive integer string }", test: isRational },
 	context_by_derive: { cell: "written by derive (object or null)", says: "null or an object", test: orNull(isObject) },
+	source_context: { cell: "quote context or null (legacy)", says: "null or { prefix, suffix } up to 32 characters each", test: orNull((v) => isObject(v) && Object.keys(v).sort().join(",") === "prefix,suffix" && [v.prefix, v.suffix].every((s) => isString(s) && [...s].length <= 32)) },
 	derived_operation: { cell: "sum/diff/growth/share/ratio/expr", says: "a derived operation", test: (v) => Object.hasOwn(OPERATION_RULES, v) && OPERATION_RULES[v].kind === "derived" },
 	convert_operation: { cell: "`convert`", says: "convert", test: (v) => Object.hasOwn(OPERATION_RULES, v) && OPERATION_RULES[v].kind === "converted" },
 	precision: { cell: "`{ places, sigfigs }`", says: "nonnegative places and positive sigfigs", test: (v) => isObject(v) && Object.keys(v).sort().join(",") === "places,sigfigs" && Number.isSafeInteger(v.places) && v.places >= 0 && Number.isSafeInteger(v.sigfigs) && v.sigfigs >= 1 },
@@ -101,14 +101,13 @@ const unsourced = { source_id: "source_or_null", locator: "locator_or_null", sna
 const row = (cells) => Object.freeze(Object.fromEntries(KIND_COLUMNS.map((column) => [column, cells[column] ?? (["precision", "compatibility"].includes(column) && cells.operation !== "null" ? column : "null")])))
 
 export const KIND_RULES = Object.freeze({
-	measured: row({ fact_id: "f_id", value: "decimal", ...sourced, rationale: "string_or_null", exact: "from_value", context: "null", operation: "null" }),
-	quote: row({ fact_id: "q_id", value: "null", ...sourced, rationale: "string_or_null", exact: "null", context: "null", operation: "null" }),
+	measured: row({ fact_id: "f_id", value: "decimal", ...sourced, rationale: "string_or_null", exact: "from_value", context: "source_context", operation: "null" }),
+	quote: row({ fact_id: "q_id", value: "null", ...sourced, rationale: "string_or_null", exact: "null", context: "source_context", operation: "null" }),
 	derived: row({ fact_id: "f_id", value: "decimal", ...unsourced, rationale: "string_or_null", exact: "by_derive", context: "context_by_derive", operation: "derived_operation" }),
 	assumed: row({ fact_id: "f_id", value: "decimal", ...unsourced, rationale: "non_empty", exact: "rational_or_null", context: "null", operation: "null" }),
 	converted: row({ fact_id: "f_id", value: "decimal", ...unsourced, rationale: "string_or_null", exact: "by_derive", context: "context_by_derive", operation: "convert_operation" }),
 })
 
-/** The id prefix nextId assigns for a kind; an unknown kind gets F and fails validation later. */
 export function idPrefix(kind) {
 	return RULES[KIND_RULES[kind]?.fact_id ?? "f_id"].prefix
 }
@@ -169,7 +168,7 @@ const carriesDerivation = (row) => row.operation !== null || row.operands?.lengt
 /** Dimension 32: a stored exact must equal the row's own value at the value's decimal places. */
 function valueExactDisagreement(row) {
 	const exact = readExact(row.exact)
-	const value = readDecimal(row.value)
+	const value = isString(row.value) ? readDecimal(row.value).replace(/^-(0+(?:\.0+)?)$/, "$1") : row.value
 	if (!isRational(exact) || !isDecimal(value) || roundPlaces(toBig(exact), placesOf(value)) === value) return null
 	return `value ${value} disagrees with exact ${exact.num}/${exact.den} at ${placesOf(value)} decimal places`
 }
@@ -212,7 +211,7 @@ export function kindRuleErrors(candidate, at) {
 		const value = candidate[column] === undefined && LATER_COLUMNS.includes(column) ? null : candidate[column]
 		const rule = RULES[legacy && column === "exact" ? "rational_or_null" : rules[column]]
 		// An exact with unknown keys loads as written (never stripped); readFlaws refuses it at use and at write.
-		if (column === "exact" && hasUnknownExactKeys(value) && !isCurrentDerived(candidate)) continue
+		if (column === "exact" && rules[column] !== "null" && hasUnknownExactKeys(value) && !isCurrentDerived(candidate)) continue
 		if (rule.test(value, candidate)) continue
 		errors.push(`${at}.${column} must be ${rule.says} for a ${candidate.kind} row`)
 		if (rule.detail) errors.push(...rule.detail(value, `${at}.${column}`))

package/dist/skills/ulw-research/scripts/fact-ledger-kinds.test.ts

@@ -62,6 +62,7 @@ const GENERATORS: Record<string, Gen> = {
 	rational_or_null: { valid: (r) => pick(r, [null, rational(r)]), invalid: (r) => pick(r, [{ num: "1", den: "0" }, { num: 1, den: "2" }, "1/2"]) },
 	by_derive: { valid: rational, invalid: (r) => pick(r, [null, { num: "1", den: "0" }, { num: "x", den: "2" }, "1/2"]) },
 	context_by_derive: { valid: (_r, row) => row.kind === "converted" ? { target: "km" } : null, invalid: (r) => pick(r, ["km", 3, ["km"], false]) },
+	source_context: { valid: (r) => pick(r, [null, { prefix: "source ", suffix: " text" }]), invalid: (r) => pick(r, [{ target: "km" }, { prefix: "x".repeat(33), suffix: "" }, { prefix: "", suffix: 3 }]) },
 	derived_operation: { valid: () => "expr", invalid: (r) => pick(r, [null, "convert", "mean"]) },
 	convert_operation: { valid: () => "convert", invalid: (r) => pick(r, [null, "sum", "mean"]) },
 	precision: { valid: () => ({ places: 2, sigfigs: 3 }), invalid: (r) => pick(r, [null, { places: -1, sigfigs: 3 }, { places: 2, sigfigs: 0 }]) },
@@ -122,7 +123,7 @@ describe("rows generated from KIND_RULES", () => {
 		expect(validateLedger(ledgerOf({ ...row, exact: { num: "-1", den: "2" } }))).toEqual([])
 	})
 
-	test("review r6 LOW 3: context is a derived or converted column; a measured, quote, or assumed row carrying one is rejected", () => {
+	test("source context rejects derivation fields, and assumed rows still require null context", () => {
 		for (const kind of ["measured", "quote", "assumed"]) {
 			const row = { ...validRow(kind, prng(3)), context: { target: "km" } }
 			expect({ kind, named: validateLedger(ledgerOf(row)).some((error: string) => error.startsWith("rows[0].context")) }).toEqual({ kind, named: true })

package/dist/skills/ulw-research/scripts/fact-ledger-legacy.test.ts

@@ -3,7 +3,8 @@ import { copyFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 
-import { derive, recompute } from "./fact-derive.mjs"
+import { recompute } from "./fact-derive.mjs"
+import { derive } from "./tests/derive-clock"
 import { LEDGER_FILENAME, addRow, emptyLedger, readLedger, validateLedger, writeLedger } from "./fact-ledger.mjs"
 
 // Generated by dev's own addRow (tests/fixtures/fidelity/gen-legacy-dev.mjs pins the dev commit):

package/dist/skills/ulw-research/scripts/fact-locate.mjs

@@ -1,10 +1,12 @@
-// fact-locate.mjs - deterministic fact locators over a source snapshot.
+// fact-locate.mjs - deterministic fact locators over a source snapshot's locator text.
 //
 // Each locator returns { value, unit, raw, quote, value_span, sentence_id, qualifier, locator } or
 // { error: "fact_not_located" | "fact_ambiguous", candidates }; it never guesses. `quote` is the
-// whole containing sentence, cell, or line of text.txt, `value_span` is [start, end] inside
-// `quote` with quote.slice(...value_span) === raw, and locator.char_start/char_end place `quote`
-// in text.txt. Every call takes `sourceId` (S<n>) so sentence ids match sentences.jsonl.
+// whole containing sentence, cell, or line of the view text (source-view.mjs: the visible text
+// nodes of a page, never markup), `value_span` is [start, end] inside `quote` with
+// quote.slice(...value_span) === raw, and locator.char_start/char_end place `quote` in that text;
+// raw-locator.mjs turns them into bytes. Every call takes `sourceId` (S<n>) so sentence ids match
+// sentences.jsonl, which indexes the same text.
 // Plain Node ESM, sibling imports only; no network, no OCR.
 
 import { proseText } from "./html-lite.mjs"
@@ -101,7 +103,8 @@ export function locateFind(text, { find, unitExpected, sourceId }) {
 	return result.unit === expected ? result : { error: "unit_expected_mismatch", expected, found: result.unit, candidates: [result] }
 }
 
-function cellsOf(row) {
+/** A row's cells by visual column (a colspan cell repeats). */
+export function cellsOf(row) {
 	const cells = []
 	for (const cell of row.children.filter((child) => child.tag === "td" || child.tag === "th")) {
 		const span = Math.max(1, Number.parseInt(cell.attrs.colspan ?? "1", 10) || 1)
@@ -110,7 +113,7 @@ function cellsOf(row) {
 	return cells
 }
 
-function rowsOf(table) {
+export function rowsOf(table) {
 	const rows = []
 	const walk = (node) => {
 		for (const child of node.children) {
@@ -142,10 +145,13 @@ function tablesOf(root) {
 const cellLabel = (cell) => label(proseText(cell))
 const indexesOf = (labels, wanted) => labels.flatMap((value, index) => (value === wanted ? [index] : []))
 
-/** --table/--row/--col: the table by id, caption, or a header label; row and column by normalized label, never by index. */
-export function locateTable(sourceHtml, { table, row, col, sourceId }) {
+/**
+ * --table/--row/--col: the table by id, caption, or a header label; row and column by normalized label,
+ * never by index. `source` is page html or an extracted view ({ root, text, blocks }) of one.
+ */
+export function locateTable(source, { table, row, col, sourceId }) {
 	requireSource(sourceId)
-	const { root, text, blocks } = snapshotBlocks(sourceHtml)
+	const { root, text, blocks } = typeof source === "string" ? snapshotBlocks(source) : source
 	const key = label(table)
 	const tables = tablesOf(root).filter((entry) => entry.table.attrs.id === table || entry.caption === key || (entry.header && cellsOf(entry.header).map(cellLabel).includes(key)))
 	if (tables.length !== 1) return tables.length === 0 ? notLocated() : ambiguous(tables.map((entry) => ({ table: entry.table.attrs.id ?? entry.caption })))

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

@@ -0,0 +1,149 @@
+import { expect, test } from "bun:test"
+import { recompute } from "./fact-derive.mjs"
+import { derive } from "./tests/derive-clock"
+import { addRow, emptyLedger, retractRow, validateLedger } from "./fact-ledger.mjs"
+import { canonicalUnit } from "./unit-rules.mjs"
+import { convertFactor } from "./units.mjs"
+import { Row, Book, now, book, row, sum, refused } from "./tests/fact-unit-dimensions-support"
+
+
+
+test("dimension 21: expression root and literal precision remain explicit", () => {
+	const l = book(["1000", "3"], ["m", "m"])
+	expect(row(l, { op: "expr", formula: "F1 - F2", unit: "m" }).value).toBe("997")
+	expect(row(l, { op: "expr", formula: "(F1 - F2) * 1", unit: "m" }).value).toBe("1000")
+	expect(row(l, { op: "expr", formula: "(F1 - F2) * 1.00", unit: "m" }).value).toBe("1000")
+})
+
+test("dimension 22: cloned snapshots are deterministic and replay appends a new identity", () => {
+	const original = book()
+	const left = structuredClone(original)
+	const right = structuredClone(original)
+	expect(row(left, sum)).toEqual(row(right, sum))
+	expect(row(left, sum).fact_id).toBe("F4")
+	expect(original.rows).toHaveLength(2)
+})
+
+test("dimension 23: coherent trusted input rewrites are a documented arithmetic limitation", () => {
+	const l = book(["0", "3"])
+	const km = row(l, { op: "convert", operands: ["F1"], to: "km" })
+	const cm = row(l, { op: "convert", operands: ["F1"], to: "cm" })
+	const coherent = { ...cm, fact_id: km.fact_id, label: km.label }
+	expect(recompute(l, coherent).ok).toBe(true)
+	expect(recompute(l, { ...km, unit: "cm" }).ok).toBe(false)
+})
+
+test("dimension 24: sum permutation and ordered arithmetic keep their own semantics", () => {
+	const l = book(["2", "5"])
+	for (const operands of [["F1", "F2"], ["F2", "F1"]]) expect(row(l, { ...sum, operands }).exact).toEqual({ num: "7", den: "1" })
+	expect(row(l, { ...sum, op: "diff" }).exact).toEqual({ num: "-3", den: "1" })
+	expect(row(l, { ...sum, op: "diff", operands: ["F2", "F1"] }).exact).toEqual({ num: "3", den: "1" })
+})
+
+test("dimension 25: numeric domain boundaries do not forbid negative ordinary arithmetic", () => {
+	for (const values of [["6", "5"], ["-1", "5"], ["0", "0"]]) expect(derive(book(values), { op: "share", part: "F1", whole: "F2", unit: "%" }).error).toBeDefined()
+	expect(row(book(["-2", "-5"]), sum).exact).toEqual({ num: "-7", den: "1" })
+	expect(derive(book(), { op: "expr", formula: "F1 / (F2 - F2)", unit: null }).error).toBeDefined()
+})
+
+test("dimension 26: percent products and pct nodes preserve fraction semantics", () => {
+	const l = book(["20", "50"], ["%", "%"])
+	expect(row(l, { op: "expr", formula: "pct(F1 * F2)", unit: "%" }).exact).toEqual({ num: "10", den: "1" })
+	expect(row(l, { op: "diff", operands: ["F2", "F1"], unit: "%p" }).exact).toEqual({ num: "30", den: "1" })
+	expect(derive(l, { op: "expr", formula: "pct(F1)", unit: "%" }).error).toBeDefined()
+})
+
+test("dimension 27: conversion maps compose with exact independent rational arithmetic", () => {
+	const groups = [["mm", "cm", "m", "km"], ["g", "kg", "t"], ["ms", "s", "min", "h"], ["B", "KB", "MB", "GB", "TB"], ["C", "F"], ["%", "\u2030"], ["KRW", "KRW-e3", "KRW-e4", "KRW-e8", "KRW-e12"]]
+	const apply = (factor: { num: bigint; den: bigint; offset?: { num: bigint; den: bigint } } | null, x: [bigint, bigint]): [bigint, bigint] => {
+		if (!factor) throw Error("missing conversion")
+		const o = factor.offset ?? { num: 0n, den: 1n }
+		return [x[0] * factor.num * o.den + o.num * x[1] * factor.den, x[1] * factor.den * o.den]
+	}
+	for (const group of groups) for (const a of group) for (const b of group) for (const c of group) {
+		for (const value of [-3n, 0n, 7n]) {
+			const direct = apply(convertFactor(a, c), [value, 1n])
+			const chained = apply(convertFactor(b, c), apply(convertFactor(a, b), [value, 1n]))
+			expect(direct[0] * chained[1]).toBe(chained[0] * direct[1])
+		}
+	}
+	expect(derive(book(), { op: "convert", operands: ["F1"], to: "furlong" }).error).toBeDefined()
+})
+
+test("dimension 28: grammar rejects injection and preserves precedence", () => {
+	for (const formula of ["F1;globalThis.x=1", "-F1", "F1 ** 2", "pct F1", "(F1", "F1 F2"]) expect(derive(book(), { op: "expr", formula, unit: "m" }).error).toBeDefined()
+	expect(row(book(), { op: "expr", formula: "F1 + F2 * 2", unit: "m" }).exact).toEqual({ num: "7", den: "1" })
+})
+
+test("dimension 29: signed rounding ties and canonical display are exact", () => {
+	for (const [values, expected] of [[["-1.25", "-2.5"], "-3.8"], [["1.25", "2.5"], "3.8"], [["999.5", "0"], "1000"]] as const) {
+		expect(row(book([...values]), sum).value).toBe(expected)
+	}
+	const l = book(["20", "15"], ["%", "%"])
+	const delta = row(l, { op: "diff", operands: ["F1", "F2"], unit: "%p" })
+	expect(recompute(l, { ...delta, render: "5 pp" }).ok).toBe(false)
+})
+
+test("dimension 30: seeded factor trees have an independent arithmetic and unit oracle", () => {
+	let seed = 0x11009
+	const next = () => { seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; return seed }
+	const atoms = ["m", "s", "person"]
+	for (let i = 0; i < 100; i++) {
+		const counts = [0, 0, 0]
+		const factors = Array.from({ length: 5 }, () => {
+			const index = next() % atoms.length
+			const exponent = (next() % 7) - 3
+			counts[index] += exponent
+			return `(${atoms[index]}^${exponent})`
+		})
+		const side = (positive: boolean) => atoms.map((a, index) => ({ a, n: counts[index] })).filter(({ n }) => positive ? n > 0 : n < 0).sort((a, b) => a.a.localeCompare(b.a)).map(({ a, n }) => Math.abs(n) === 1 ? a : `${a}^${Math.abs(n)}`)
+		const top = side(true).join("*") || "1"
+		const bottom = side(false)
+		const expectedUnit = bottom.length ? `${top}/${bottom.length === 1 ? bottom[0] : `(${bottom.join("*")})`}` : top === "1" ? null : top
+		expect(canonicalUnit(factors.join("*"))).toBe(expectedUnit)
+		const a = BigInt(1 + next() % 100)
+		const b = BigInt(1 + next() % 100)
+		const l = book([String(a), String(b)], [factors.join("*"), "person"])
+		const result = row(l, { op: "expr", formula: "F1 * F2 / F2", unit: expectedUnit })
+		expect(result.exact).toEqual({ num: String(a), den: "1" })
+		expect(result.unit).toBe(expectedUnit)
+		expect(recompute(l, result).ok).toBe(true)
+		expect(recompute(l, { ...result, exact: { num: String(a + 1n), den: "1" } }).ok).toBe(false)
+	}
+})
+
+test("dimension 30: independent rational oracle crosses every operation with metadata and tampering", () => {
+	let state = 3917
+	const next = () => { state = (Math.imul(state, 1103515245) + 12345) >>> 0; return state }
+	const exact = (n: bigint, d = 1n) => {
+		let a = n < 0n ? -n : n
+		let b = d
+		while (b) [a, b] = [b, a % b]
+		return { num: String(n / a), den: String(d / a) }
+	}
+	for (let i = 0; i < 50; i++) {
+		const a = BigInt(1 + next() % 50)
+		const b = a + BigInt(1 + next() % 50)
+		const meta = { population: { country: "x", cohort: i }, accounting_basis: "cash", snapshot_window: "2026", entity: "acme" }
+		const specs: Array<[Row, { num: string; den: string }]> = [
+			[{ ...sum }, exact(a + b)],
+			[{ ...sum, op: "diff" }, exact(a - b)],
+			[{ op: "ratio", num: "F1", den: "F2", unit: null }, exact(a, b)],
+			[{ op: "share", part: "F1", whole: "F2", unit: "%" }, exact(100n * a, b)],
+			[{ op: "growth", from: "F1", to: "F2", unit: "%" }, exact(100n * (b - a), a)],
+			[{ op: "convert", operands: ["F1"], to: "cm" }, exact(100n * a)],
+			[{ op: "expr", formula: "F1 * 2 / F2", unit: null }, exact(2n * a, b)],
+		]
+		for (const [spec, expected] of specs) {
+			const l = book([String(a), String(b)], ["metre", "m"], [{ ...meta, valid_at: "2025" }, { ...meta, valid_at: "2026" }])
+			const result = row(l, spec)
+			expect(result.exact).toEqual(expected)
+			expect(recompute(l, result).ok).toBe(true)
+			expect(recompute(l, { ...result, unit: "person" }).ok).toBe(false)
+			expect(recompute(l, { ...result, exact: { num: String(BigInt(expected.num) + 1n), den: expected.den } }).ok).toBe(false)
+		}
+		const l = book([String(100n * a), String(b)], ["bp/person", "person"])
+		const result = row(l, { op: "expr", formula: "F1 * F2", unit: "%p" })
+		expect(result.exact).toEqual(exact(a * b))
+	}
+})

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

@@ -1,36 +1,12 @@
 import { expect, test } from "bun:test"
-
-import { derive, recompute } from "./fact-derive.mjs"
+import { recompute } from "./fact-derive.mjs"
+import { derive } from "./tests/derive-clock"
 import { addRow, emptyLedger, retractRow, validateLedger } from "./fact-ledger.mjs"
 import { canonicalUnit } from "./unit-rules.mjs"
 import { convertFactor } from "./units.mjs"
+import { Row, Book, now, book, row, sum, refused } from "./tests/fact-unit-dimensions-support"
+
 
-type Row = Record<string, unknown>
-type Book = { schemaVersion: number; rows: Row[]; events: unknown[] }
-const now = "2026-10-23T08:00:00Z"
-function book(values: string[] = ["1", "3"], units: Array<string | null> = ["m", "m"], extras: Row[] = []): Book {
-	const ledger = emptyLedger() as Book
-	values.forEach((value, i) => addRow(ledger, {
-		kind: "measured", value, unit: units[i], raw: value, quote: value, source_id: "S1",
-		locator: { artifact: "sources/S1/text.txt", char_start: 0, char_end: 1 },
-		snapshot_sha256: "a".repeat(64), extracted_by: "test", observed_at: now, label: `f${i + 1}`,
-		...extras[i],
-	}))
-	return ledger
-}
-function row(ledger: Book, spec: Row): Row {
-	const result = derive(ledger, { ...spec, now })
-	if (!("row" in result)) throw Error(JSON.stringify(result))
-	return result.row as Row
-}
-const sum = { op: "sum", operands: ["F1", "F2"], unit: "m" }
-function refused(ledger: Book, spec: unknown) {
-	const before = structuredClone(ledger)
-	const result = derive(ledger, spec)
-	expect(result).toMatchObject({ error: "incompatible_operands" })
-	expect(ledger).toEqual(before)
-	return result
-}
 
 test("dimension 01: kind operation consistency cannot disable recursive trust", () => {
 	for (const patch of [{ operation: null }, { kind: "measured" }, { operation: "convert" }]) {
@@ -267,143 +243,3 @@ test("dimension 20: supplied expression operand set must match formula leaves",
 	for (const operands of [["F2"], ["F1", "F2"], ["F1", "F1"], [], null]) refused(book(), { op: "expr", formula: "F1", unit: "m", operands })
 	expect(row(book(), { op: "expr", formula: "F1 + F2", operands: ["F2", "F1"], unit: "m" }).value).toBe("4")
 })
-
-test("dimension 21: expression root and literal precision remain explicit", () => {
-	const l = book(["1000", "3"], ["m", "m"])
-	expect(row(l, { op: "expr", formula: "F1 - F2", unit: "m" }).value).toBe("997")
-	expect(row(l, { op: "expr", formula: "(F1 - F2) * 1", unit: "m" }).value).toBe("1000")
-	expect(row(l, { op: "expr", formula: "(F1 - F2) * 1.00", unit: "m" }).value).toBe("1000")
-})
-
-test("dimension 22: cloned snapshots are deterministic and replay appends a new identity", () => {
-	const original = book()
-	const left = structuredClone(original)
-	const right = structuredClone(original)
-	expect(row(left, sum)).toEqual(row(right, sum))
-	expect(row(left, sum).fact_id).toBe("F4")
-	expect(original.rows).toHaveLength(2)
-})
-
-test("dimension 23: coherent trusted input rewrites are a documented arithmetic limitation", () => {
-	const l = book(["0", "3"])
-	const km = row(l, { op: "convert", operands: ["F1"], to: "km" })
-	const cm = row(l, { op: "convert", operands: ["F1"], to: "cm" })
-	const coherent = { ...cm, fact_id: km.fact_id, label: km.label }
-	expect(recompute(l, coherent).ok).toBe(true)
-	expect(recompute(l, { ...km, unit: "cm" }).ok).toBe(false)
-})
-
-test("dimension 24: sum permutation and ordered arithmetic keep their own semantics", () => {
-	const l = book(["2", "5"])
-	for (const operands of [["F1", "F2"], ["F2", "F1"]]) expect(row(l, { ...sum, operands }).exact).toEqual({ num: "7", den: "1" })
-	expect(row(l, { ...sum, op: "diff" }).exact).toEqual({ num: "-3", den: "1" })
-	expect(row(l, { ...sum, op: "diff", operands: ["F2", "F1"] }).exact).toEqual({ num: "3", den: "1" })
-})
-
-test("dimension 25: numeric domain boundaries do not forbid negative ordinary arithmetic", () => {
-	for (const values of [["6", "5"], ["-1", "5"], ["0", "0"]]) expect(derive(book(values), { op: "share", part: "F1", whole: "F2", unit: "%" }).error).toBeDefined()
-	expect(row(book(["-2", "-5"]), sum).exact).toEqual({ num: "-7", den: "1" })
-	expect(derive(book(), { op: "expr", formula: "F1 / (F2 - F2)", unit: null }).error).toBeDefined()
-})
-
-test("dimension 26: percent products and pct nodes preserve fraction semantics", () => {
-	const l = book(["20", "50"], ["%", "%"])
-	expect(row(l, { op: "expr", formula: "pct(F1 * F2)", unit: "%" }).exact).toEqual({ num: "10", den: "1" })
-	expect(row(l, { op: "diff", operands: ["F2", "F1"], unit: "%p" }).exact).toEqual({ num: "30", den: "1" })
-	expect(derive(l, { op: "expr", formula: "pct(F1)", unit: "%" }).error).toBeDefined()
-})
-
-test("dimension 27: conversion maps compose with exact independent rational arithmetic", () => {
-	const groups = [["mm", "cm", "m", "km"], ["g", "kg", "t"], ["ms", "s", "min", "h"], ["B", "KB", "MB", "GB", "TB"], ["C", "F"], ["%", "\u2030"], ["KRW", "KRW-e3", "KRW-e4", "KRW-e8", "KRW-e12"]]
-	const apply = (factor: { num: bigint; den: bigint; offset?: { num: bigint; den: bigint } } | null, x: [bigint, bigint]): [bigint, bigint] => {
-		if (!factor) throw Error("missing conversion")
-		const o = factor.offset ?? { num: 0n, den: 1n }
-		return [x[0] * factor.num * o.den + o.num * x[1] * factor.den, x[1] * factor.den * o.den]
-	}
-	for (const group of groups) for (const a of group) for (const b of group) for (const c of group) {
-		for (const value of [-3n, 0n, 7n]) {
-			const direct = apply(convertFactor(a, c), [value, 1n])
-			const chained = apply(convertFactor(b, c), apply(convertFactor(a, b), [value, 1n]))
-			expect(direct[0] * chained[1]).toBe(chained[0] * direct[1])
-		}
-	}
-	expect(derive(book(), { op: "convert", operands: ["F1"], to: "furlong" }).error).toBeDefined()
-})
-
-test("dimension 28: grammar rejects injection and preserves precedence", () => {
-	for (const formula of ["F1;globalThis.x=1", "-F1", "F1 ** 2", "pct F1", "(F1", "F1 F2"]) expect(derive(book(), { op: "expr", formula, unit: "m" }).error).toBeDefined()
-	expect(row(book(), { op: "expr", formula: "F1 + F2 * 2", unit: "m" }).exact).toEqual({ num: "7", den: "1" })
-})
-
-test("dimension 29: signed rounding ties and canonical display are exact", () => {
-	for (const [values, expected] of [[["-1.25", "-2.5"], "-3.8"], [["1.25", "2.5"], "3.8"], [["999.5", "0"], "1000"]] as const) {
-		expect(row(book([...values]), sum).value).toBe(expected)
-	}
-	const l = book(["20", "15"], ["%", "%"])
-	const delta = row(l, { op: "diff", operands: ["F1", "F2"], unit: "%p" })
-	expect(recompute(l, { ...delta, render: "5 pp" }).ok).toBe(false)
-})
-
-test("dimension 30: seeded factor trees have an independent arithmetic and unit oracle", () => {
-	let seed = 0x11009
-	const next = () => { seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; return seed }
-	const atoms = ["m", "s", "person"]
-	for (let i = 0; i < 100; i++) {
-		const counts = [0, 0, 0]
-		const factors = Array.from({ length: 5 }, () => {
-			const index = next() % atoms.length
-			const exponent = (next() % 7) - 3
-			counts[index] += exponent
-			return `(${atoms[index]}^${exponent})`
-		})
-		const side = (positive: boolean) => atoms.map((a, index) => ({ a, n: counts[index] })).filter(({ n }) => positive ? n > 0 : n < 0).sort((a, b) => a.a.localeCompare(b.a)).map(({ a, n }) => Math.abs(n) === 1 ? a : `${a}^${Math.abs(n)}`)
-		const top = side(true).join("*") || "1"
-		const bottom = side(false)
-		const expectedUnit = bottom.length ? `${top}/${bottom.length === 1 ? bottom[0] : `(${bottom.join("*")})`}` : top === "1" ? null : top
-		expect(canonicalUnit(factors.join("*"))).toBe(expectedUnit)
-		const a = BigInt(1 + next() % 100)
-		const b = BigInt(1 + next() % 100)
-		const l = book([String(a), String(b)], [factors.join("*"), "person"])
-		const result = row(l, { op: "expr", formula: "F1 * F2 / F2", unit: expectedUnit })
-		expect(result.exact).toEqual({ num: String(a), den: "1" })
-		expect(result.unit).toBe(expectedUnit)
-		expect(recompute(l, result).ok).toBe(true)
-		expect(recompute(l, { ...result, exact: { num: String(a + 1n), den: "1" } }).ok).toBe(false)
-	}
-})
-
-test("dimension 30: independent rational oracle crosses every operation with metadata and tampering", () => {
-	let state = 3917
-	const next = () => { state = (Math.imul(state, 1103515245) + 12345) >>> 0; return state }
-	const exact = (n: bigint, d = 1n) => {
-		let a = n < 0n ? -n : n
-		let b = d
-		while (b) [a, b] = [b, a % b]
-		return { num: String(n / a), den: String(d / a) }
-	}
-	for (let i = 0; i < 50; i++) {
-		const a = BigInt(1 + next() % 50)
-		const b = a + BigInt(1 + next() % 50)
-		const meta = { population: { country: "x", cohort: i }, accounting_basis: "cash", snapshot_window: "2026", entity: "acme" }
-		const specs: Array<[Row, { num: string; den: string }]> = [
-			[{ ...sum }, exact(a + b)],
-			[{ ...sum, op: "diff" }, exact(a - b)],
-			[{ op: "ratio", num: "F1", den: "F2", unit: null }, exact(a, b)],
-			[{ op: "share", part: "F1", whole: "F2", unit: "%" }, exact(100n * a, b)],
-			[{ op: "growth", from: "F1", to: "F2", unit: "%" }, exact(100n * (b - a), a)],
-			[{ op: "convert", operands: ["F1"], to: "cm" }, exact(100n * a)],
-			[{ op: "expr", formula: "F1 * 2 / F2", unit: null }, exact(2n * a, b)],
-		]
-		for (const [spec, expected] of specs) {
-			const l = book([String(a), String(b)], ["metre", "m"], [{ ...meta, valid_at: "2025" }, { ...meta, valid_at: "2026" }])
-			const result = row(l, spec)
-			expect(result.exact).toEqual(expected)
-			expect(recompute(l, result).ok).toBe(true)
-			expect(recompute(l, { ...result, unit: "person" }).ok).toBe(false)
-			expect(recompute(l, { ...result, exact: { num: String(BigInt(expected.num) + 1n), den: expected.den } }).ok).toBe(false)
-		}
-		const l = book([String(100n * a), String(b)], ["bp/person", "person"])
-		const result = row(l, { op: "expr", formula: "F1 * F2", unit: "%p" })
-		expect(result.exact).toEqual(exact(a * b))
-	}
-})