lazycodex-ai 5.1.44 → 5.1.46

package/packages/shared-skills/skills/ulw-research/scripts/polish-apply.test.ts

@@ -0,0 +1,363 @@
+import { describe, expect, test } from "bun:test"
+
+import { FACT_ELEMENT_TAGS, renderBlockquote, renderQuote, renderValueHtml } from "./placeholder.mjs"
+import { applyEdits, cutSpan, POLISH_EDIT_FIELDS, project, validatePolishEdits } from "./polish-apply.mjs"
+import { diffPolish } from "./polish-diff.mjs"
+
+type Row = { fact_id: string; kind: string; quote: string; raw: string; value: string; unit: string | null; qualifier: string | null }
+const row = (fact_id: string, quote: string, raw: string, value: string, unit: string | null, qualifier: string | null = null): Row => ({
+	fact_id,
+	kind: "measured",
+	quote,
+	raw,
+	value,
+	unit,
+	qualifier,
+})
+const REVENUE = row("F1", "Revenue was about 10 million USD in 2025.", "10 million USD", "10000000", "USD", "approximate")
+const SPAN = row("F2", "The bridge has a main span of 320 m.", "320 m", "320", "m")
+const USERS = row("F3", "Usage reached 5,000 users.", "5,000 users", "5000", "users")
+const BOUND = row("F4", "The bridge has a main span of up to 320 m.", "320 m", "320", "m", "upper_inclusive")
+const LEDGER = { schemaVersion: 1, rows: [REVENUE, SPAN, USERS, BOUND], events: [] }
+const f = (r: Row) => renderValueHtml(r, r.raw)
+const doc = (body: string) => `<html><body>\n${body}\n</body></html>`
+const edit = (before: string, after: string, reason = "polish") => ({ before, after, reason })
+const codes = (list: { code: string }[]) => list.map((item) => item.code)
+
+describe("applyEdits: hedges and qualifiers", () => {
+	test("removing 'about' that the row quote carries is rejected and leaves the paragraph unchanged", () => {
+		const html = doc(`<p>Revenue was about ${f(REVENUE)}.</p>`)
+		const result = applyEdits(html, [edit(`Revenue was about ${f(REVENUE)}.`, `Revenue was ${f(REVENUE)}.`)], LEDGER)
+		expect(result.applied).toEqual([])
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("about")
+		expect(result.out).toBe(html)
+	})
+
+	test("removing a hedge the row quote lacks is applied", () => {
+		const html = doc(`<p>The span was about ${f(SPAN)}.</p>`)
+		const result = applyEdits(html, [edit("The span was about ", "The span was ")], LEDGER)
+		expect(result.applied).toEqual([0])
+		expect(result.rejected).toEqual([])
+		expect(result.out).toBe(doc(`<p>The span was ${f(SPAN)}.</p>`))
+	})
+
+	test("dropping the row's qualifier ('up to') is rejected", () => {
+		const html = doc(`<p>The main span is up to ${f(BOUND)}.</p>`)
+		const result = applyEdits(html, [edit(`The main span is up to ${f(BOUND)}.`, `The main span is ${f(BOUND)}.`)], LEDGER)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("up to")
+	})
+
+	test("a claim-only sentence keeps the hedges of before", () => {
+		const html = doc("<p>Results may improve [S1].</p>")
+		expect(codes(applyEdits(html, [edit("Results may improve [S1].", "Results improve [S1].")], LEDGER).rejected)).toEqual(["polish_edit_rejected"])
+	})
+})
+
+describe("applyEdits: fact spans and numerals", () => {
+	test("splitting a sentence with its fact spans intact is applied", () => {
+		const html = doc(`<p>The span is ${f(SPAN)} and usage is ${f(USERS)}.</p>`)
+		const result = applyEdits(html, [edit(" and usage is ", ". Usage is ")], LEDGER)
+		expect(result.applied).toEqual([0])
+		expect(result.out).toBe(doc(`<p>The span is ${f(SPAN)}. Usage is ${f(USERS)}.</p>`))
+	})
+
+	test("swapping two numerals is rejected", () => {
+		const html = doc("<p>See Figure 1 and Figure 2 [S1].</p>")
+		const result = applyEdits(html, [edit("See Figure 1 and Figure 2 [S1].", "See Figure 2 and Figure 1 [S1].")], LEDGER)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("numeral")
+	})
+
+	test("moving a decimal point is rejected", () => {
+		const html = doc("<p>Throughput grew 3.5 times [S1].</p>")
+		expect(codes(applyEdits(html, [edit("grew 3.5 times", "grew 35 times")], LEDGER).rejected)).toEqual(["polish_edit_rejected"])
+	})
+
+	test("changing a plain unit ('320 m' to '320 mm') is rejected with a reason", () => {
+		const html = doc("<p>The span is 320 m [S1].</p>")
+		const result = applyEdits(html, [edit("The span is 320 m [S1].", "The span is 320 mm [S1].")], LEDGER)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("numeral")
+	})
+
+	test("swapping the order of two fact spans is rejected", () => {
+		const html = doc(`<p>The span is ${f(SPAN)} and usage is ${f(USERS)}.</p>`)
+		const before = `The span is ${f(SPAN)} and usage is ${f(USERS)}.`
+		const after = `Usage is ${f(USERS)} and the span is ${f(SPAN)}.`
+		expect(codes(applyEdits(html, [edit(before, after)], LEDGER).rejected)).toEqual(["polish_edit_rejected"])
+	})
+
+	test("editing the rendered value inside a fact span is rejected", () => {
+		const html = doc(`<p>The span is ${f(SPAN)}.</p>`)
+		const changed = f(SPAN).replace(">320 m<", ">321 m<")
+		expect(codes(applyEdits(html, [edit(f(SPAN), changed)], LEDGER).rejected)).toEqual(["polish_edit_rejected"])
+	})
+})
+
+describe("applyEdits: links and location", () => {
+	test("changing a link is rejected", () => {
+		const html = doc('<p><a href="https://example.invalid/a">Reference</a> [S1].</p>')
+		const before = '<a href="https://example.invalid/a">Reference</a>'
+		const result = applyEdits(html, [edit(before, before.replace("/a", "/b"))], LEDGER)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("href")
+	})
+
+	test("changing a data-claim id is rejected", () => {
+		const html = doc('<p data-claim="C1">Results improve [S1].</p>')
+		const result = applyEdits(html, [edit('data-claim="C1"', 'data-claim="C2"')], LEDGER)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("markup changed")
+	})
+
+	test("a before that is not found is unlocated", () => {
+		const result = applyEdits(doc("<p>Text [S1].</p>"), [edit("ABSENT", "replacement")], LEDGER)
+		expect(codes(result.unlocated)).toEqual(["polish_edit_unlocated"])
+		expect(result.applied).toEqual([])
+	})
+
+	test("a before that occurs twice is unlocated", () => {
+		const result = applyEdits(doc("<p>The term and term appear [S1].</p>"), [edit("term", "word")], LEDGER)
+		expect(codes(result.unlocated)).toEqual(["polish_edit_unlocated"])
+	})
+
+	test("before matches across normalized whitespace", () => {
+		const html = doc("<p>Results\n   improve [S1].</p>")
+		const result = applyEdits(html, [edit("Results improve [S1].", "Results clearly improve [S1].")], LEDGER)
+		expect(result.applied).toEqual([0])
+		expect(result.out).toBe(doc("<p>Results clearly improve [S1].</p>"))
+	})
+
+	test("edits apply in order; a later edit whose before is gone is unlocated", () => {
+		const html = doc("<p>Results improve [S1].</p>")
+		const result = applyEdits(
+			html,
+			[edit("Results improve [S1].", "Results improve steadily [S1]."), edit("Results improve [S1].", "Results improve rapidly [S1].")],
+			LEDGER,
+		)
+		expect(result.applied).toEqual([0])
+		expect(result.unlocated.map((item: { index: number }) => item.index)).toEqual([1])
+		expect(result.out).toBe(doc("<p>Results improve steadily [S1].</p>"))
+	})
+
+	test("a rejected edit does not block a later good edit", () => {
+		const html = doc(`<p>Revenue was about ${f(REVENUE)}.</p><p>Results improve [S1].</p>`)
+		const result = applyEdits(
+			html,
+			[edit(`Revenue was about ${f(REVENUE)}.`, `Revenue was ${f(REVENUE)}.`), edit("Results improve [S1].", "Results clearly improve [S1].")],
+			LEDGER,
+		)
+		expect(result.applied).toEqual([1])
+		expect(result.rejected.map((item: { index: number }) => item.index)).toEqual([0])
+		expect(result.out).toBe(doc(`<p>Revenue was about ${f(REVENUE)}.</p><p>Results clearly improve [S1].</p>`))
+	})
+})
+
+describe("applyEdits: rendered visibility (review #11152 round 1)", () => {
+	const html = doc(`<p>The span is ${f(SPAN)} [S1].</p>`)
+	const hide = (after: string) => applyEdits(html, [edit(f(SPAN), after)], LEDGER)
+	test.each([
+		["an HTML comment", `<!-- ${f(SPAN)} -->`],
+		["a hidden attribute", `<span hidden>${f(SPAN)}</span>`],
+		["display:none", `<span style="display: none">${f(SPAN)}</span>`],
+		["visibility:hidden", `<span style="visibility:hidden">${f(SPAN)}</span>`],
+		["font-size:0", `<span style="font-size:0px">${f(SPAN)}</span>`],
+		["a template", `<template>${f(SPAN)}</template>`],
+		["an unclosed hidden wrapper", `<div hidden>${f(SPAN)}`],
+	])("a fact span wrapped in %s is rejected and leaves the document unchanged", (_label, after) => {
+		const result = hide(after)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("markup changed")
+		expect(result.out).toBe(html)
+	})
+
+	test("a data-claim span moved into a comment is rejected", () => {
+		const claim = doc('<p><span data-claim="C1">Results improve</span> [S1].</p>')
+		const before = '<span data-claim="C1">Results improve</span>'
+		expect(codes(applyEdits(claim, [edit(before, `<!-- ${before} -->Results improve`)], LEDGER).rejected)).toEqual(["polish_edit_rejected"])
+	})
+
+	test("a hedge hidden with a hidden attribute is rejected", () => {
+		const claim = doc("<p>Results may improve [S1].</p>")
+		const result = applyEdits(claim, [edit("Results may improve", "Results <span hidden>may</span> improve")], LEDGER)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("markup changed")
+	})
+})
+
+describe("applyEdits: the same rules as diffPolish (review #11152 round 1)", () => {
+	test("adding a ticker is rejected", () => {
+		const result = applyEdits(doc("<p>The firm reported growth [S1].</p>"), [edit("The firm reported", "AAPL reported")], LEDGER)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("tickers")
+	})
+
+	test("renaming an id that an internal link targets is rejected", () => {
+		const html = doc('<h2 id="s1">Method</h2><p><a href="#s1">Method</a> [S1].</p>')
+		const result = applyEdits(html, [edit('id="s1"', 'id="s2"')], LEDGER)
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("#s1")
+	})
+
+	test("dropping a table row is rejected", () => {
+		const html = doc("<table><tr><td>A</td></tr><tr><td>B</td></tr></table>")
+		expect(codes(applyEdits(html, [edit("<tr><td>B</td></tr>", "")], LEDGER).rejected)).toEqual(["polish_edit_rejected"])
+	})
+
+	test("cumulative churn is caught at the edit that crosses the limit, against the original document", () => {
+		const html = doc("<p>Alpha beta gamma. Delta epsilon zeta. Eta theta iota. Kappa lambda mu.</p>")
+		const edits = [edit("Alpha beta gamma.", "Nu xi omicron."), edit("Delta epsilon zeta.", "Rho sigma tau."), edit("Eta theta iota.", "Phi chi psi.")]
+		const result = applyEdits(html, edits, LEDGER)
+		expect(result.rejected.length).toBeGreaterThan(0)
+		expect(result.rejected.at(-1)?.reason).toContain("percent of the normalized prose")
+		expect(diffPolish(html, result.out, LEDGER)).toEqual([])
+	})
+})
+
+describe("applyEdits: one baseline with diffPolish (review #11152 round 2, M1)", () => {
+	const TOWER = row("F7", "The tower is 320 m tall.", "320 m", "320", "m")
+	const ledger = { ...LEDGER, rows: [...LEDGER.rows, TOWER] }
+	const html = doc(`<p>The tower is ${f(TOWER)} tall. It may be the tallest.</p>`)
+	const pair = [edit(" tall. It may be", " tall and may be"), edit("and may be the tallest", "and is the tallest")]
+
+	test("each edit of the hedge-stripping pair alone keeps the hedge", () => {
+		expect(applyEdits(html, [pair[0]], ledger).applied).toEqual([0])
+		const merged = applyEdits(html, [pair[0]], ledger).out
+		expect(diffPolish(merged, applyEdits(merged, [pair[1]], ledger).out, ledger)).toEqual([])
+	})
+
+	test("the pair together is refused at the second edit, which strips the source document's hedge", () => {
+		const result = applyEdits(html, pair, ledger)
+		expect(result.applied).toEqual([0])
+		expect(codes(result.rejected)).toEqual(["polish_edit_rejected"])
+		expect(result.rejected[0].reason).toContain("may")
+		expect(diffPolish(html, result.out, ledger)).toEqual([])
+	})
+
+	test("no cross-edit case remains: every applyEdits output is diffPolish-clean against the input", () => {
+		const cases: [string, { before: string; after: string; reason: string }[]][] = [
+			[html, pair],
+			[doc("<p>Alpha beta gamma. Delta epsilon zeta. Eta theta iota. Kappa lambda mu.</p>"), [edit("Alpha beta gamma.", "Nu xi omicron."), edit("Delta epsilon zeta.", "Rho sigma tau."), edit("Eta theta iota.", "Phi chi psi.")]],
+			[doc(`<p>The span is ${f(SPAN)} and usage is ${f(USERS)}.</p>`), [edit(" and usage is", ". Usage is"), edit("The span is", "Usage is"), edit(". Usage is", " and the span is")]],
+		]
+		for (const [input, edits] of cases) expect(diffPolish(input, applyEdits(input, edits, ledger).out, ledger)).toEqual([])
+	})
+})
+
+describe("applyEdits: hidden content keeps its bytes and its class (review #11152 round 2, H1 and M2)", () => {
+	const refused = (html: string, edits: { before: string; after: string; reason: string }[], word: string) => {
+		const result = applyEdits(html, edits, LEDGER)
+		expect(result.applied).toEqual([])
+		expect(result.out).toBe(html)
+		expect(result.rejected.map((item: { reason: string }) => item.reason).join(" | ")).toContain(word)
+	}
+	const flagged = (before: string, after: string) => expect(codes(diffPolish(before, after, LEDGER))).toContain("polish_diff_fail")
+
+	test("probe 1: a number under aria-hidden renders, so editing it is refused and flagged", () => {
+		const html = doc('<p>Growth was <span aria-hidden="true">3.2% in 2024</span> overall.</p>')
+		refused(html, [edit("3.2% in 2024", "9.9% in 2031")], "numerals")
+		flagged(html, html.replace("3.2% in 2024", "9.9% in 2031"))
+	})
+
+	test("probe 2: a number after an unclosed <p hidden> is inside the hidden region, whose bytes may not change", () => {
+		const html = doc("<p hidden>note<div>Revenue was 5 billion.</div>")
+		refused(html, [edit("5 billion", "50 billion")], "numerals")
+		flagged(html, html.replace("5 billion", "50 billion"))
+	})
+
+	test("a legitimately hidden region left byte-identical does not block a visible edit", () => {
+		const html = doc("<p hidden>internal note 42</p><p>Results improve [S1].</p><!-- build 7 -->")
+		const result = applyEdits(html, [edit("Results improve [S1].", "Results clearly improve [S1].")], LEDGER)
+		expect(result.applied).toEqual([0])
+		expect(diffPolish(html, result.out, LEDGER)).toEqual([])
+	})
+
+	const shown = doc(`<p>The span is <span>${f(SPAN)}</span> [S1].</p>`)
+	const changed = f(SPAN).replace(">320 m<", ">321 m<")
+	test("relabelling a visible fact span as hidden while changing its number, in one edit, is refused and flagged", () => {
+		refused(shown, [edit(`<span>${f(SPAN)}</span>`, `<span hidden>${changed}</span>`)], "markup changed")
+		flagged(shown, shown.replace(`<span>${f(SPAN)}</span>`, `<span hidden>${changed}</span>`))
+	})
+
+	test("the two-edit variant (hide, then change) is refused at both edits and flagged", () => {
+		const edits = [edit(`<span>${f(SPAN)}`, `<span style="display:none">${f(SPAN)}`), edit(">320 m<", ">321 m<")]
+		const result = applyEdits(shown, edits, LEDGER)
+		expect(result.applied).toEqual([])
+		expect(result.rejected[0].reason).toContain("markup changed")
+		flagged(shown, shown.replace(`<span>${f(SPAN)}</span>`, `<span style="display:none">${changed}</span>`))
+	})
+
+	test("unhiding a hidden fact span with a changed value is refused and flagged", () => {
+		const hidden = doc(`<p>The span is <span hidden>${f(SPAN)}</span> [S1].</p>`)
+		refused(hidden, [edit(`<span hidden>${f(SPAN)}</span>`, `<span>${changed}</span>`)], "markup changed")
+		flagged(hidden, hidden.replace(`<span hidden>${f(SPAN)}</span>`, `<span>${changed}</span>`))
+	})
+
+	test("a pure change of a fact or claim span's visibility class is flagged in both directions", () => {
+		const claim = doc('<p><span data-claim="C1">Results improve</span> [S1].</p>')
+		const hiddenClaim = claim.replace('<span data-claim="C1">', '<span hidden data-claim="C1">')
+		for (const [before, after] of [[claim, hiddenClaim], [hiddenClaim, claim]]) {
+			expect(diffPolish(before, after, LEDGER).find((d: { code: string }) => d.code === "polish_diff_fail")?.message).toContain("markup changed")
+		}
+	})
+
+	test.each([
+		["color:transparent"],
+		["max-height:0;overflow:hidden"],
+		["position:absolute;left:-9999px"],
+		["clip-path:inset(50%)"],
+		["transform:scale(0)"],
+	])("M2: wrapping a fact span in style=%s changes the markup and is refused and flagged", (style) => {
+		const html = doc(`<p>The span is ${f(SPAN)} [S1].</p>`)
+		refused(html, [edit(f(SPAN), `<span style="${style}">${f(SPAN)}</span>`)], "markup")
+		flagged(html, html.replace(f(SPAN), `<span style="${style}">${f(SPAN)}</span>`))
+	})
+
+	test("M2: inserting a stylesheet is refused and flagged", () => {
+		const html = doc(`<p>The span is ${f(SPAN)} [S1].</p>`)
+		refused(html, [edit("The span is", "<style>.x{display:none}</style>The span is")], "markup")
+		flagged(html, html.replace("The span is", "<style>.x{display:none}</style>The span is"))
+	})
+})
+
+describe("polish fact spans come from the placeholder renderers (duplication sweep)", () => {
+	const source = { ...SPAN, source_id: "S1", entity: null, valid_at: null }
+	const rendered = [renderValueHtml(source, source.raw), renderQuote(source, "p:nth-of-type(1)", source.quote, "html"), renderBlockquote(source, "k1", "html")]
+
+	test("the renderers emit exactly the FACT_ELEMENT_TAGS elements", () => {
+		expect(rendered.map((html) => html.match(/^<([a-z]+)/)?.[1]).sort()).toEqual([...FACT_ELEMENT_TAGS].sort())
+	})
+
+	test.each(rendered.map((html) => [html.match(/^<([a-z]+)/)?.[1], html]))("project and cutSpan recognize a rendered <%s>", (_tag, html) => {
+		const markup = `<p>Before ${html} after.</p>`
+		expect(project(markup).facts.map((fact: { id: string }) => fact.id)).toEqual(["F2"])
+		const at = markup.indexOf(html)
+		expect(cutSpan(markup, at + 3, at + html.length + 2)).toBe("F2")
+		expect(cutSpan(markup, at, at + html.length)).toBeNull()
+	})
+})
+
+describe("validatePolishEdits: the edit contract (duplication sweep)", () => {
+	test("the contract names before and after as required and reason as optional", () => {
+		expect(POLISH_EDIT_FIELDS).toEqual({ before: "required", after: "required", reason: "optional" })
+	})
+
+	test.each([
+		["a non-array", { before: "a", after: "b" }, "array"],
+		["a null entry", [null], "edit 0"],
+		["a non-string before", [{ before: 1, after: "b" }], "before"],
+		["a missing after", [{ before: "a" }], "after"],
+		["a non-string reason", [{ before: "a", after: "b", reason: 3 }], "reason"],
+	])("%s is refused with a TypeError, by the validator and by applyEdits alike", (_label, edits, word) => {
+		expect(() => validatePolishEdits(edits)).toThrow(TypeError)
+		expect(() => validatePolishEdits(edits)).toThrow(word)
+		expect(() => applyEdits("<p>a</p>", edits as never, LEDGER)).toThrow(word)
+	})
+
+	test("an edit without a reason is valid", () => {
+		const edits = [{ before: "a", after: "b" }]
+		expect(validatePolishEdits(edits)).toBe(edits)
+	})
+})

package/packages/shared-skills/skills/ulw-research/scripts/polish-diff.mjs

@@ -0,0 +1,31 @@
+// polish-diff.mjs - whole-document backstop between a pre-polish artifact and its polished result.
+//
+// diffPolish(beforeHtml, afterHtml, ledger) runs the polish-rules.mjs rule set (the same rules
+// polish-apply runs per edit) over the whole document, as multisets, and returns at most one defect
+// per code. Severity is looked up in contracts.DEFECT_CODES for every emitted code; a code missing
+// there throws. polish-apply checks every edit against this same whole-document baseline (ordered,
+// so stricter), so a clean polish-apply run is clean here; this catches hand edits. No IO, no model.
+// Plain Node ESM.
+
+import { DEFECT_CODES } from "./contracts.mjs"
+import { POLISH_CODES, polishDefects } from "./polish-rules.mjs"
+
+export { churnRatio, TICKER } from "./polish-rules.mjs"
+
+/** The DEFECT_CODES entry of a polish code; refuses a code the registry does not define. */
+function registryEntry(code) {
+	if (!Object.hasOwn(DEFECT_CODES, code)) throw new Error(`polish code ${code} is not in DEFECT_CODES`)
+	return DEFECT_CODES[code]
+}
+
+/**
+ * @param {string} beforeHtml the pre-polish artifact
+ * @param {string} afterHtml the polished artifact
+ * @param {{ rows: object[] }} ledger
+ * @returns {{ code: string, severity: string, message: string }[]} at most one defect per code
+ */
+export function diffPolish(beforeHtml, afterHtml, ledger) {
+	const found = new Map()
+	for (const { code, message } of polishDefects(beforeHtml, afterHtml, ledger)) found.set(code, [...(found.get(code) ?? []), message])
+	return POLISH_CODES.filter((code) => found.has(code)).map((code) => ({ code, severity: registryEntry(code).severity, message: found.get(code).join("; ") }))
+}

package/packages/shared-skills/skills/ulw-research/scripts/polish-diff.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { renderValueHtml } from "./placeholder.mjs"
+import { DEFECT_CODES } from "./contracts.mjs"
+import * as polishDiff from "./polish-diff.mjs"
+import * as polishProject from "./polish-project.mjs"
+import * as polishRules from "./polish-rules.mjs"
+
+const { diffPolish } = polishDiff
+
+const SPAN = { fact_id: "F2", kind: "measured", quote: "The bridge has a main span of 320 m.", raw: "320 m", value: "320", unit: "m", qualifier: null }
+const MAKER = { fact_id: "F5", kind: "measured", quote: "In May, Samsung Electronics shipped 12 units.", raw: "12 units", value: "12", unit: "units", qualifier: null }
+const SALES = { fact_id: "F6", kind: "measured", quote: "Sales were approximately 7 units.", raw: "7 units", value: "7", unit: "units", qualifier: null }
+const LEDGER = { schemaVersion: 1, rows: [SPAN, MAKER, SALES], events: [] }
+const span = renderValueHtml(SPAN, SPAN.raw)
+const doc = (body: string) => `<html><body>\n${body}\n</body></html>`
+const codes = (list: { code: string }[]) => list.map((item) => item.code)
+
+describe("diffPolish: protected content", () => {
+	test("identical documents have no defects", () => {
+		const html = doc(`<p>The span was about ${span} [S1].</p><table><tr><td>A</td></tr></table>`)
+		expect(diffPolish(html, html, LEDGER)).toEqual([])
+	})
+
+	test("one numeral that differs inside a fact span is polish_diff_fail", () => {
+		const before = doc(`<p>The span is ${span} [S1].</p>`)
+		const after = doc(`<p>The span is ${span.replace(">320 m<", ">321 m<")} [S1].</p>`)
+		expect(codes(diffPolish(before, after, LEDGER))).toEqual(["polish_diff_fail"])
+	})
+
+	test("one numeral that differs outside fact spans is polish_diff_fail", () => {
+		const before = doc("<p>Throughput grew 3.5 times in the pilot [S1].</p>")
+		const after = doc("<p>Throughput grew 35 times in the pilot [S1].</p>")
+		expect(codes(diffPolish(before, after, LEDGER))).toEqual(["polish_diff_fail"])
+	})
+
+	test("a dropped table row is polish_diff_fail", () => {
+		const before = doc("<table><tr><td>A</td></tr><tr><td>B</td></tr></table>")
+		const after = doc("<table><tr><td>A</td></tr></table>")
+		expect(codes(diffPolish(before, after, LEDGER))).toContain("polish_diff_fail")
+	})
+
+	test("a changed ticker or six-digit exchange code is polish_diff_fail", () => {
+		expect(codes(diffPolish(doc("<p>AAPL [S1].</p>"), doc("<p>MSFT [S1].</p>"), LEDGER))).toEqual(["polish_diff_fail"])
+		expect(codes(diffPolish(doc("<p>Code 005930 [S1].</p>"), doc("<p>Code 000660 [S1].</p>"), LEDGER))).toEqual(["polish_diff_fail"])
+	})
+})
+
+describe("diffPolish: hedges, churn, links and names", () => {
+	test("two hedges removed from claim-only text is polish_hedging_decreased", () => {
+		const before = doc("<p>Results may improve and are provisional. The study covered the pilot only.</p>")
+		const after = doc("<p>Results improve and are final. The study covered the pilot only.</p>")
+		expect(codes(diffPolish(before, after, LEDGER))).toEqual(["polish_hedging_decreased"])
+	})
+
+	test("deleting a writer-added hedge the source lacks is not a hedge loss", () => {
+		const before = doc(`<p>The span was about ${span} [S1].</p>`)
+		const after = doc(`<p>The span was ${span} [S1].</p>`)
+		expect(diffPolish(before, after, LEDGER)).toEqual([])
+	})
+
+	test("a 60 percent rewrite is polish_text_churn and 50 percent is not", () => {
+		expect(codes(diffPolish(doc("<p>abcdefghij</p>"), doc("<p>klmnopghij</p>"), LEDGER))).toEqual(["polish_text_churn"])
+		expect(diffPolish(doc("<p>abcdefghij</p>"), doc("<p>klmnofghij</p>"), LEDGER)).toEqual([])
+	})
+
+	test("a changed link target or an internal link that stops resolving is polish_link_changed", () => {
+		const link = (href: string) => doc(`<p id="top"><a href="${href}">Reference</a> [S1].</p>`)
+		expect(codes(diffPolish(link("https://example.invalid/a"), link("https://example.invalid/b"), LEDGER))).toEqual(["polish_diff_fail", "polish_link_changed"])
+		const before = doc('<h2 id="m">Method</h2><p><a href="#m">Method</a> [S1].</p>')
+		const after = doc('<h2 id="method">Method</h2><p><a href="#m">Method</a> [S1].</p>')
+		expect(codes(diffPolish(before, after, LEDGER))).toEqual(["polish_diff_fail", "polish_link_changed"])
+	})
+
+	test("a ledger-quote name present before and absent after is polish_name_changed", () => {
+		const before = doc("<p>Samsung Electronics shipped more units in the quarter [S1].</p>")
+		const after = doc("<p>The company shipped more units in the quarter [S1].</p>")
+		expect(codes(diffPolish(before, after, LEDGER))).toEqual(["polish_name_changed"])
+	})
+
+	test("every defect carries its fixed severity", () => {
+		const before = doc("<p>Results may improve and are provisional [S1].</p><table><tr><td>A</td></tr><tr><td>B</td></tr></table>")
+		const after = doc("<p>Results improve and are final [S1].</p><table><tr><td>A</td></tr></table>")
+		const defects = diffPolish(before, after, LEDGER)
+		expect(codes(defects)).toEqual(["polish_diff_fail", "polish_hedging_decreased"])
+		for (const defect of defects) expect(defect.severity).toBe(DEFECT_CODES[defect.code].severity)
+	})
+})
+
+describe("diffPolish: severities come from DEFECT_CODES (review #11152 round 1)", () => {
+	test("no polish module exports a local severity table", () => {
+		for (const mod of [polishDiff, polishRules]) expect(Object.keys(mod).filter((name) => /severity/i.test(name))).toEqual([])
+		for (const file of ["polish-diff.mjs", "polish-rules.mjs", "polish-apply.mjs", "polish-project.mjs"]) {
+			const source = readFileSync(join(import.meta.dir, file), "utf8")
+			expect(source.match(/["'](?:blocker|major|minor)["']/g) ?? [], file).toEqual([])
+		}
+	})
+
+	test("every polish code resolves through DEFECT_CODES and each defect carries that severity", () => {
+		for (const code of polishRules.POLISH_CODES) expect(Object.hasOwn(DEFECT_CODES, code), code).toBe(true)
+		const before = doc('<p>Samsung Electronics may improve [S1].</p><p><a href="/a">x</a> abcdefghij</p><table><tr><td>A</td></tr><tr><td>B</td></tr></table>')
+		const after = doc('<p>The firm improves [S1].</p><p><a href="/b">x</a> klmnopqrstuvwxyz</p><table><tr><td>A</td></tr></table>')
+		const defects = diffPolish(before, after, LEDGER)
+		expect(codes(defects)).toEqual([...polishRules.POLISH_CODES])
+		for (const defect of defects) expect(defect.severity, defect.code).toBe(DEFECT_CODES[defect.code].severity)
+	})
+})
+
+describe("diffPolish: rendered visibility and hedge comparison (review #11152 round 1)", () => {
+	test.each([
+		["a hidden attribute", `<span hidden>${span}</span>`],
+		["display:none", `<span style="display:none">${span}</span>`],
+		["a template", `<template>${span}</template>`],
+	])("a fact span hidden by %s is polish_diff_fail", (_label, hidden) => {
+		expect(codes(diffPolish(doc(`<p>The span is ${span} [S1].</p>`), doc(`<p>The span is ${hidden} [S1].</p>`), LEDGER))).toContain("polish_diff_fail")
+	})
+
+	test("wrapping a hedge changes markup and is blocked before full fidelity verification", () => {
+		const after = doc("<p>Results <span hidden>may</span> improve [S1].</p>")
+		expect(codes(diffPolish(doc("<p>Results may improve [S1].</p>"), after, LEDGER))).toEqual(["polish_diff_fail"])
+	})
+
+	test("a ledger hedge the sentence never held is not a decrease", () => {
+		const sales = renderValueHtml(SALES, SALES.raw)
+		const before = doc(`<p>The share of revenue was ${sales} [S1].</p>`)
+		const after = doc(`<p>The share in revenue was ${sales} [S1].</p>`)
+		expect(diffPolish(before, after, LEDGER)).toEqual([])
+	})
+
+	test("single-quoted and unquoted href changes are polish_link_changed", () => {
+		expect(codes(diffPolish(doc("<p><a href='/a'>x</a></p>"), doc("<p><a href='/b'>x</a></p>"), LEDGER))).toEqual(["polish_diff_fail", "polish_link_changed"])
+		expect(codes(diffPolish(doc("<p><a href=/a>x</a></p>"), doc("<p><a href=/b>x</a></p>"), LEDGER))).toEqual(["polish_diff_fail", "polish_link_changed"])
+	})
+
+	test("the same input gives byte-identical output", () => {
+		const before = doc("<p>Results may improve and are provisional [S1].</p>")
+		const after = doc("<p>Results improve and are final [S1].</p>")
+		expect(JSON.stringify(diffPolish(before, after, LEDGER))).toBe(JSON.stringify(diffPolish(before, after, LEDGER)))
+	})
+})
+
+describe("claim ids and fact-span scanning (review #11152 round 2, L1 and L2)", () => {
+	test("L1: a changed data-claim id is a blocking polish_diff_fail, as apply treats it, not a minor link change", () => {
+		const defects = diffPolish(doc('<p data-claim="C1">Results improve [S1].</p>'), doc('<p data-claim="C2">Results improve [S1].</p>'), LEDGER)
+		expect(codes(defects)).toEqual(["polish_diff_fail"])
+		expect(defects[0].severity).toBe(DEFECT_CODES.polish_diff_fail.severity)
+		expect(defects[0].message).toContain("markup changed")
+	})
+
+	test("L2: a nested same-name element and a quoted '>' stay inside one fact span", () => {
+		const nested = '<p><q data-fact="F1">a <q>b</q> c</q> d</p>'
+		expect(polishProject.factSpans(nested).map((s: { html: string }) => s.html)).toEqual(['<q data-fact="F1">a <q>b</q> c</q>'])
+		const quoted = '<p><data title="a>b" data-fact="F2">320 m</data> d</p>'
+		expect(polishProject.factSpans(quoted).map((s: { id: string; html: string }) => [s.id, s.html])).toEqual([["F2", '<data title="a>b" data-fact="F2">320 m</data>']])
+	})
+})
+
+describe("polish policies have one owner (duplication sweep)", () => {
+	test("the named policies are exported once, from their owners", () => {
+		expect(polishRules.POLISH_CHURN_LIMIT).toBe(0.5)
+		expect("Samsung Electronics".match(polishRules.POLISH_NAME)).toEqual(["Samsung", "Electronics"])
+		expect(polishDiff.TICKER).toBe(polishRules.TICKER)
+		expect(polishProject.POLISH_LINK_ATTRIBUTES).toEqual(["href"])
+		expect("v1.25 and 3,000".match(polishProject.POLISH_DIGITS)).toEqual(["1.25", "3,000"])
+	})
+})