oh-my-opencode 5.0.0-beta.9 → 5.0.0

package/packages/omo-codex/plugin/skills/ulw-research/scripts/gates-layout.mjs

@@ -0,0 +1,146 @@
+// gates-layout.mjs - L1-L5 geometric gates over the layout probe output (boxes.json).
+//
+// Pure functions over the object layout-probe.mjs returns: no browser, no DOM, and selectors are
+// taken verbatim from the probe (the probe already built them with the html-lite rule). Severities
+// and hints are read from contracts.DEFECT_CODES, never set here. Measured pixel amounts are
+// rounded to 0.1px (the probe's own precision) before a threshold compare, so float noise such as
+// 2.000000000000001 never crosses a 2px limit.
+
+import { DEFECT_CODES } from "./contracts.mjs"
+import { PROBE_VERSION, ProbeError } from "./layout-probe.mjs"
+
+/** Thresholds (draft D10): rounding tolerances, not taste. */
+export const OVERFLOW_PX = 2
+export const SCROLL_SLACK_PX = 2
+export const ASPECT_DRIFT = 0.03
+export const OVERLAP_PX = 12
+
+const OUT_OF_FLOW = new Set(["absolute", "fixed"])
+const IN_FLOW = new Set(["static", "relative"])
+const CLIPPING = new Set(["hidden", "clip"])
+const SCROLLING = new Set(["auto", "scroll"])
+const ASPECT_SAFE_FITS = new Set(["cover", "contain", "scale-down"])
+
+const r1 = (n) => Math.round(n * 10) / 10
+
+/**
+ * @typedef {{ code: string, severity: string, selector: string, line: null, message: string, hint: string }} Defect
+ */
+function defect(code, selector, message) {
+	const { severity, hint } = DEFECT_CODES[code]
+	return { code, severity, selector, line: null, message, hint }
+}
+
+// L1: the largest spill of the child rect past any side of its parent rect. A parent that scrolls
+// on the spill axis makes it intentional scrolling (the advisory scroll container); a parent that
+// clips on that axis hides the spilled content (text clipped).
+function checkOverflow(box) {
+	if (!box.parentRect || OUT_OF_FLOW.has(box.position)) return null
+	const c = box.rect
+	const p = box.parentRect
+	const sides = [
+		["left", p.x - c.x],
+		["top", p.y - c.y],
+		["right", c.x + c.w - (p.x + p.w)],
+		["bottom", c.y + c.h - (p.y + p.h)],
+	].map(([side, px]) => [side, r1(px)])
+	const [side, px] = sides.reduce((worst, entry) => (entry[1] > worst[1] ? entry : worst))
+	if (px <= OVERFLOW_PX) return null
+	const parentMode = box.parentOverflow?.[side === "left" || side === "right" ? "x" : "y"]
+	if (SCROLLING.has(parentMode)) {
+		return defect("layout_scroll_container", box.selector, `${box.tag} is ${px}px wider than ${box.parentSelector}, which scrolls (overflow: ${parentMode})`)
+	}
+	if (CLIPPING.has(parentMode)) {
+		return defect("layout_text_clipped", box.selector, `${box.tag} spills ${px}px past the ${side} edge of ${box.parentSelector}, which clips it (overflow: ${parentMode})`)
+	}
+	return defect("layout_overflow", box.selector, `${box.tag} spills ${px}px past the ${side} edge of ${box.parentSelector}`)
+}
+
+// L2/L3: content larger than the box on an axis whose computed overflow clips or scrolls.
+function checkScroll(box) {
+	const { sw, cw, sh, ch } = box.scroll
+	const axes = [
+		["x", sw - cw, box.overflow.x],
+		["y", sh - ch, box.overflow.y],
+	].filter(([, excess]) => r1(excess) > SCROLL_SLACK_PX)
+	const clipped = axes.find(([, , mode]) => CLIPPING.has(mode))
+	if (clipped) {
+		const [axis, excess, mode] = clipped
+		return defect("layout_text_clipped", box.selector, `${box.tag} content exceeds its box by ${r1(excess)}px on ${axis} under overflow: ${mode}`)
+	}
+	const scrolled = axes.find(([, , mode]) => SCROLLING.has(mode))
+	if (scrolled) {
+		const [axis, excess, mode] = scrolled
+		return defect("layout_scroll_container", box.selector, `${box.tag} scrolls ${r1(excess)}px on ${axis} under overflow: ${mode}`)
+	}
+	return null
+}
+
+// L4: rendered aspect ratio drifting from the natural one without an aspect-preserving fit.
+function checkAspect(box) {
+	if (box.tag !== "img" || !box.natural) return null
+	const { w, h } = box.rect
+	const { w: nw, h: nh } = box.natural
+	if (!(w > 0 && h > 0 && nw > 0 && nh > 0)) return null
+	const fit = box.objectFit ?? "fill"
+	if (ASPECT_SAFE_FITS.has(fit)) return null
+	const drift = Math.abs(w / h / (nw / nh) - 1)
+	if (drift <= ASPECT_DRIFT) return null
+	const percent = (drift * 100).toFixed(1)
+	return defect("layout_image_distorted", box.selector, `img rendered ${w}x${h} from natural ${nw}x${nh} distorts the aspect ratio by ${percent}% (object-fit: ${fit})`)
+}
+
+function intersection(a, b) {
+	const ix = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)
+	const iy = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y)
+	return { ix: r1(ix), iy: r1(iy) }
+}
+
+// L5: in-flow siblings (same parentSelector) whose rects intersect by more than 12px on both axes.
+function checkSiblings(boxes) {
+	const groups = new Map()
+	for (const box of boxes) {
+		if (box.parentSelector === null || box.parentSelector === undefined || !IN_FLOW.has(box.position)) continue
+		const group = groups.get(box.parentSelector) ?? []
+		group.push(box)
+		groups.set(box.parentSelector, group)
+	}
+	const defects = []
+	for (const group of groups.values()) {
+		for (let i = 0; i < group.length; i += 1) {
+			for (let j = i + 1; j < group.length; j += 1) {
+				const { ix, iy } = intersection(group[i].rect, group[j].rect)
+				if (Math.min(ix, iy) <= OVERLAP_PX) continue
+				defects.push(defect("layout_sibling_overlap", group[i].selector, `${group[i].selector} and ${group[j].selector} overlap by ${ix}x${iy}px`))
+			}
+		}
+	}
+	return defects
+}
+
+function validateProbe(probe) {
+	if (probe === null || typeof probe !== "object") throw new ProbeError("invalid_probe", "layout probe must be an object")
+	if (probe.probe_version !== PROBE_VERSION) {
+		throw new ProbeError("unsupported_probe_version", `layout probe_version must be ${PROBE_VERSION}, got ${probe.probe_version}`)
+	}
+	if (!Array.isArray(probe.boxes)) throw new ProbeError("invalid_probe", "layout probe boxes must be an array")
+}
+
+/**
+ * @param {{ probe_version: number, count?: number, truncated?: boolean, boxes: object[] }} probe
+ * @returns {{ defects: Defect[], summary: string }}
+ */
+export function checkLayout(probe) {
+	validateProbe(probe)
+	const defects = []
+	for (const box of probe.boxes) {
+		for (const rule of [checkOverflow, checkScroll, checkAspect]) {
+			const found = rule(box)
+			if (found) defects.push(found)
+		}
+	}
+	defects.push(...checkSiblings(probe.boxes))
+	let summary = `layout: ${probe.boxes.length} boxes checked, ${defects.length} defects`
+	if (probe.truncated) summary += `; layout sample truncated`
+	return { defects, summary }
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/gates-static.mjs

@@ -0,0 +1,167 @@
+// gates-static.mjs - deterministic static gates (G1-G15) over a parsed report.
+//
+// Builds one document context (a document-order walk with h2 sections, citation helpers and a
+// defect factory) and hands it to the text, figure and structure gate modules. Every severity
+// comes from contracts.DEFECT_CODES; the single override is unsourced_number under
+// `Lineage: section`, derived from the spec mode passed in, never from a caller-supplied
+// severity. Plain Node ESM, node: builtins and siblings only.
+
+import * as nodeFs from "node:fs"
+
+import { DEFECT_CODES, LINEAGE_MODES } from "./contracts.mjs"
+import { customProperties } from "./css-lite.mjs"
+import { figureGates } from "./gates-figures.mjs"
+import { structureGates } from "./gates-structure.mjs"
+import { textGates } from "./gates-text.mjs"
+import { PROSE_TAGS, proseText, selectorPath } from "./html-lite.mjs"
+
+const CITATION_MARKER = /\[S\d+\]|\[Source\s*\d+\]|\[\uCD9C\uCC98[^\]]*\]|\[\^\d+\]/i
+const ANCHOR_HREF = /^#(?:s|src|source|ref|fn)/i
+const ANCHOR_TEXT = /^\[(?:\uCD9C\uCC98|Source\s*\d+|S\d+)\]$/i
+/** Closing ("how this report was made") heading; Korean alternates cover the same register. */
+export const CLOSING_HEADING = /\b(?:method(?:ology)?|how)\b|\uB4B7\uBA74|\uBC29\uBC95|\uC5B4\uB5BB\uAC8C|\uB9CC\uB4E4\uC5B4/i
+export const SOURCES_HEADING = /references|sources|bibliography|\uCD9C\uCC98|\uCC38\uACE0\s*(?:\uBB38\uD5CC|\uC790\uB8CC)/i
+const OTHER_KINDS = [
+	["toc", /\b(?:contents|toc)\b|\uBAA9\uCC28/i],
+	["appendix", /appendix|\uBD80\uB85D/i],
+	["glossary", /glossary|\uC6A9\uC5B4/i],
+]
+const TEXT_SKIP = new Set(["code", "pre", "kbd", "samp", "script", "style", "svg", "template", "noscript"])
+const HEADING_TAG = /^h[1-6]$/
+/** The one sanctioned severity override: section-level lineage demotes unsourced_number. */
+const SECTION_LINEAGE_SEVERITY = "minor"
+
+const GATES = [...textGates, ...figureGates, ...structureGates]
+
+function classTokens(node) {
+	return String(node.attrs.class ?? "").toLowerCase().split(/\s+/).filter(Boolean)
+}
+
+function closest(node, predicate) {
+	for (let cur = node.parent; cur; cur = cur.parent) if (predicate(cur)) return cur
+	return null
+}
+
+function descendants(node, out = []) {
+	for (const child of node.children) {
+		if (child.tag === "#text") continue
+		out.push(child)
+		descendants(child, out)
+	}
+	return out
+}
+
+function isCitationAnchor(node) {
+	return node.tag === "a" && (ANCHOR_HREF.test(node.attrs.href ?? "") || ANCHOR_TEXT.test(proseText(node)))
+}
+
+/** A citation marker in the element's prose or a citation anchor below it. */
+function hasCitation(node) {
+	return CITATION_MARKER.test(proseText(node)) || descendants(node).some(isCitationAnchor)
+}
+
+function toRegExp(pattern) {
+	const re = pattern instanceof RegExp ? pattern : new RegExp(String(pattern), "i")
+	return new RegExp(re.source, re.flags.replace(/[gy]/g, ""))
+}
+
+function findBody(doc) {
+	const stack = [doc]
+	while (stack.length) {
+		const node = stack.pop()
+		if (node.tag === "body") return node
+		for (const child of node.children) if (child.tag !== "#text") stack.push(child)
+	}
+	return doc
+}
+
+function sectionKind(text, closingTest) {
+	if (SOURCES_HEADING.test(text)) return "sources"
+	if (closingTest(text)) return "closing"
+	return OTHER_KINDS.find(([, re]) => re.test(text))?.[0] ?? null
+}
+
+/** Document-order walk of body: element scopes, prose text entries with owners, h2 sections. */
+function walkBody(ctx, node, state) {
+	for (const child of node.children) {
+		if (child.tag === "#text") {
+			if (state.skip) continue
+			ctx.texts.push({ node: child, owner: state.owner ?? node, cell: state.cell, scope: ctx.scope })
+			if (ctx.scope.section && !state.heading) ctx.scope.section.prose.push(child.text)
+			continue
+		}
+		if (child.tag === "h2") {
+			const section = { heading: child, kind: sectionKind(proseText(child), ctx.isClosing), prose: [], anchors: 0 }
+			ctx.sections.push(section)
+			ctx.scope = { section, closingH3: false }
+		} else if (child.tag === "h3") {
+			ctx.scope = { section: ctx.scope.section, closingH3: ctx.isClosing(proseText(child)) }
+		}
+		ctx.elements.push({ node: child, scope: ctx.scope })
+		if (ctx.scope.section && isCitationAnchor(child)) ctx.scope.section.anchors++
+		walkBody(ctx, child, {
+			skip: state.skip || TEXT_SKIP.has(child.tag),
+			owner: PROSE_TAGS.has(child.tag) ? child : state.owner,
+			cell: state.cell || child.tag === "td" || child.tag === "th",
+			heading: state.heading || HEADING_TAG.test(child.tag),
+		})
+	}
+}
+
+function buildContext(doc, options) {
+	const lineageMode = options.lineageMode ?? "inline"
+	if (!LINEAGE_MODES.includes(lineageMode)) throw new TypeError(`lineageMode must be one of ${LINEAGE_MODES.join(", ")}`)
+	const closingPattern = options.closingPattern ? toRegExp(options.closingPattern) : null
+	const all = descendants(doc)
+	const styleBlocks = all.filter((node) => node.tag === "style").map((node) => ({ node, css: node.raw ?? "" }))
+	const styleAttrs = all.filter((node) => node.attrs.style).map((node) => ({ node, css: node.attrs.style }))
+	const ctx = {
+		doc,
+		body: findBody(doc),
+		all,
+		elements: [],
+		texts: [],
+		sections: [],
+		scope: { section: null, closingH3: false },
+		styleBlocks,
+		styleAttrs,
+		tokens: customProperties(styleBlocks.map((entry) => entry.css).join("\n")).light,
+		palette: new Set(options.palette ?? []),
+		requireSections: (options.requireSections ?? []).map(toRegExp),
+		baseDir: options.baseDir ?? null,
+		fs: options.fs ?? nodeFs,
+		isClosing: (text) => CLOSING_HEADING.test(text) || Boolean(closingPattern?.test(text)),
+		util: { classTokens, closest, descendants, hasCitation, citationMarker: CITATION_MARKER },
+		kindOf: (scope) => (scope.closingH3 ? "closing" : (scope.section?.kind ?? null)),
+		defect(code, node, message) {
+			const entry = DEFECT_CODES[code]
+			const severity = code === "unsourced_number" && lineageMode === "section" ? SECTION_LINEAGE_SEVERITY : entry.severity
+			return { code, severity, selector: selectorPath(node) || node.tag, line: node.line, message, hint: entry.hint }
+		},
+	}
+	walkBody(ctx, ctx.body, { skip: false, owner: null, cell: false, heading: false })
+	return ctx
+}
+
+/**
+ * Run G1-G15 over a parsed report (html-lite root).
+ * @param {object} doc parseHtml(...) result
+ * @param {{ palette?: Set<string>, lineageMode?: "inline"|"section", requireSections?: (RegExp|string)[],
+ *   baseDir?: string, fs?: { statSync(path: string): { size: number } }, closingPattern?: RegExp|string }} options
+ * @returns {{ defects: object[], gatesRun: string[], gatesSkipped: string[] }}
+ */
+export function checkStatic(doc, options = {}) {
+	const ctx = buildContext(doc, options)
+	const defects = []
+	const gatesRun = []
+	const gatesSkipped = []
+	for (const gate of GATES) {
+		if (gate.skip?.(ctx)) {
+			gatesSkipped.push(...gate.codes)
+			continue
+		}
+		gatesRun.push(...gate.codes)
+		defects.push(...gate.run(ctx))
+	}
+	return { defects, gatesRun, gatesSkipped }
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/gates-structure.mjs

@@ -0,0 +1,118 @@
+// gates-structure.mjs - structure gates: G11 section without citation, G12 closing section,
+// G13 citation section, G14 broken asset reference, G15 required sections.
+//
+// Each gate is { codes, skip?(ctx), run(ctx) -> Defect[] } over the context built by
+// gates-static.mjs. Plain Node ESM, node: builtins and siblings only.
+
+import { join } from "node:path"
+
+import { proseText } from "./html-lite.mjs"
+
+const MIN_SECTION_PROSE = 120
+const UNCHECKED_KINDS = new Set(["closing", "sources", "toc", "appendix", "glossary"])
+const DEFINITION_TAGS = new Set(["p", "li", "dd", "dt", "td"])
+const DEFINITION_LINE = /^\[(S|Source\s*)(\d+)\]/i
+const MIN_DEFINITIONS = 3
+const NOT_RELATIVE = /^(?:[a-z][a-z\d+.-]*:|\/\/|\/|#)/i
+
+function headingNodes(ctx, tags) {
+	return ctx.elements.map(({ node }) => node).filter((node) => tags.includes(node.tag))
+}
+
+/** Local references an asset gate checks: img src, source srcset, stylesheet href, script src. */
+function assetReferences(ctx) {
+	const refs = []
+	for (const node of ctx.all) {
+		const { attrs } = node
+		if (node.tag === "img" && attrs.src) refs.push({ node, url: attrs.src })
+		else if (node.tag === "script" && attrs.src) refs.push({ node, url: attrs.src })
+		else if (node.tag === "link" && attrs.href && /(?:^|\s)stylesheet(?:\s|$)/i.test(attrs.rel ?? "")) refs.push({ node, url: attrs.href })
+		else if (node.tag === "source" && attrs.srcset) {
+			for (const candidate of attrs.srcset.split(",")) {
+				const url = candidate.trim().split(/\s+/)[0]
+				if (url) refs.push({ node, url })
+			}
+		}
+	}
+	return refs.filter(({ url }) => url.trim() && !NOT_RELATIVE.test(url.trim()))
+}
+
+function localPath(baseDir, url) {
+	const bare = url.trim().replace(/[?#].*$/, "")
+	let decoded = bare
+	try {
+		decoded = decodeURIComponent(bare)
+	} catch {
+		// a malformed %-escape is kept verbatim; the stat below reports it as missing
+	}
+	return join(baseDir, ...decoded.split("/"))
+}
+
+function assetProblem(fs, file) {
+	try {
+		const stat = fs.statSync(file)
+		return stat.size === 0 ? "is 0 bytes" : null
+	} catch (error) {
+		return `is missing (${error?.code ?? "stat failed"})`
+	}
+}
+
+export const structureGates = [
+	{
+		codes: ["section_without_citation"],
+		run(ctx) {
+			const defects = []
+			for (const section of ctx.sections) {
+				if (UNCHECKED_KINDS.has(section.kind)) continue
+				const prose = section.prose.join(" ").replace(/\s+/g, " ").trim()
+				if (prose.length < MIN_SECTION_PROSE || section.anchors > 0 || ctx.util.citationMarker.test(prose)) continue
+				const title = proseText(section.heading)
+				defects.push(ctx.defect("section_without_citation", section.heading, `section "${title}" has ${prose.length} prose characters and no citation marker or anchor`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["missing_closing_section"],
+		run(ctx) {
+			if (headingNodes(ctx, ["h2", "h3"]).some((node) => ctx.isClosing(proseText(node)))) return []
+			return [ctx.defect("missing_closing_section", ctx.body, "no h2/h3 heading names how the report was made (method / how)")]
+		},
+	},
+	{
+		codes: ["missing_citation_section"],
+		run(ctx) {
+			if (ctx.sections.some((section) => section.kind === "sources")) return []
+			const ids = new Set()
+			for (const { node } of ctx.elements) {
+				if (!DEFINITION_TAGS.has(node.tag)) continue
+				const match = DEFINITION_LINE.exec(proseText(node))
+				if (match) ids.add(`${match[1].trim().toLowerCase()}${match[2]}`)
+			}
+			if (ids.size >= MIN_DEFINITIONS) return []
+			return [ctx.defect("missing_citation_section", ctx.body, `no references/sources h2 and ${ids.size} [S<n>] definition line(s) (< ${MIN_DEFINITIONS})`)]
+		},
+	},
+	{
+		codes: ["broken_asset_reference"],
+		skip: (ctx) => !ctx.baseDir,
+		run(ctx) {
+			const defects = []
+			for (const { node, url } of assetReferences(ctx)) {
+				const problem = assetProblem(ctx.fs, localPath(ctx.baseDir, url))
+				if (problem) defects.push(ctx.defect("broken_asset_reference", node, `<${node.tag}> asset "${url}" ${problem}`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["missing_required_section"],
+		skip: (ctx) => ctx.requireSections.length === 0,
+		run(ctx) {
+			const titles = headingNodes(ctx, ["h1", "h2", "h3", "h4", "h5", "h6"]).map((node) => proseText(node))
+			return ctx.requireSections
+				.filter((re) => !titles.some((title) => re.test(title)))
+				.map((re) => ctx.defect("missing_required_section", ctx.body, `no heading matches the required section ${re}`))
+		},
+	},
+]

package/packages/omo-codex/plugin/skills/ulw-research/scripts/gates-text.mjs

@@ -0,0 +1,190 @@
+// gates-text.mjs - prose gates: G1 keep-all, G3 emoji, G4 dashes, G5/G6 headings, G7 unsourced numbers.
+//
+// Each gate is { codes, run(ctx) -> Defect[] } over the context built by gates-static.mjs.
+// Plain Node ESM, sibling imports only.
+
+import { proseText } from "./html-lite.mjs"
+
+const HANGUL = /[\uAC00-\uD7A3]/g
+const KEEP_ALL = /word-break\s*:\s*keep-all/i
+const MIN_HANGUL = 20
+/** Dingbats (2700-27BF) that render as emoji without FE0F (Emoji_Presentation=Yes). */
+const DINGBAT_EMOJI = new Set([0x2705, 0x270a, 0x270b, 0x2728, 0x274c, 0x274e, 0x2753, 0x2754, 0x2755, 0x2757, 0x2795, 0x2796, 0x2797, 0x27b0, 0x27bf])
+const EM_DASH = "\u2014"
+const EN_DASH = "\u2013"
+const HEADING_NUMBER = /^\s*(?:\d+(?:[.-]\d+)*[.):]?|[IVXLC]+[.)]|[A-Z][.)])\s+/
+const GENERIC = new Set(["overview", "introduction", "background", "summary", "conclusion", "conclusions", "results", "discussion", "methodology"])
+const MAX_HEADING_HANGUL = 26
+const MAX_HEADING_WORDS = 12
+const LINEAGE_TOKEN = /\b(?:MEASURED|ASSUMED|DERIVED)\b/
+const NUMBER_CONTAINERS = new Set(["figure", "table", "nav", "header", "footer"])
+const MAX_UNSOURCED = 50
+const MONTH = "(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\\.?"
+/** Stripped before claim detection: dates, versions, figure refs, times, bare years. */
+const NOT_CLAIMS = [
+	/\b\d{4}[-./]\d{1,2}(?:[-./]\d{1,2})?\b/g,
+	/\b\d{2}\.\d{2}\.\d{2}\b/g,
+	/\d{2,4}\s*\uB144\s*\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
+	/\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
+	/(?:19|20)\d{2}\s*\uB144/g,
+	new RegExp(`\\b${MONTH}\\s+\\d{1,2}(?:st|nd|rd|th)?(?:,?\\s+\\d{4})?`, "gi"),
+	new RegExp(`\\b\\d{1,2}(?:st|nd|rd|th)?\\s+${MONTH}(?:\\s+\\d{4})?`, "gi"),
+	/\bv\d+(?:\.\d+)*\b|\b\d+(?:\.\d+){2,}\b/gi,
+	/\b(?:version|ver\.?|release)\s*\d+(?:\.\d+)*/gi,
+	/\b(?:fig(?:ure)?\.?|table|chart|section|step|phase|wave|part)\s*\d+(?:\.\d+)*/gi,
+	/(?:\uADF8\uB9BC|\uB3C4\uD45C|\uD45C|\uBC84\uC804)\s*\d+(?:\.\d+)*/g,
+	/\b\d{1,2}:\d{2}\b/g,
+	/\b(?:19|20)\d{2}s?\b/g,
+]
+const NUM = "(?<![\\p{L}\\d.,])\\d+(?:[.,]\\d+)*"
+const UNIT =
+	"(?:%|\\u2030|\\u00D7|\\uD37C\\uC13C\\uD2B8|\\uB2EC\\uB7EC|\\uC720\\uB85C|\\uC5D4|\\uC6D0|\\uB9CC|\\uC5B5|\\uC870|\\uCC9C|\\uCD08|\\uBD84|\\uC2DC\\uAC04|\\uC77C|\\uC8FC|\\uAC1C\\uC6D4|\\uB144|\\uBA85|\\uAC74|\\uAC1C|\\uD68C|\\uBC88|\\uBC30" +
+	"|(?:percent|pp|bps?|x|k|m|b|bn|million|billion|thousand|trillion|usd|krw|eur|ms|s|secs?|seconds?|mins?|minutes?|h|hrs?|hours?|days?|weeks?|months?|years?|kb|mb|gb|tb|users?|people|employees|engineers|tokens?|requests?|stars?|downloads?|customers?)(?![\\p{L}\\d]))"
+const CLAIMS = [
+	new RegExp(`[$\\u20AC\\u00A3\\u00A5\\u20A9]\\s?${NUM}`, "u"),
+	new RegExp(`${NUM}\\s?${UNIT}`, "iu"),
+	/(?<![\d.,])\d{1,3}(?:,\d{3})+(?![\d,])/,
+	/(?<![\d.])\d+\.\d+(?![\d.])/,
+]
+
+function snippet(text, index, span = 24) {
+	return text.slice(Math.max(0, index - span), index + span).trim()
+}
+
+/** Concatenated prose per owning element, in document order; `keep` filters text entries. */
+function ownerTexts(ctx, keep) {
+	const byOwner = new Map()
+	for (const entry of ctx.texts) {
+		if (!keep(entry)) continue
+		byOwner.set(entry.owner, (byOwner.get(entry.owner) ?? "") + entry.node.text)
+	}
+	return [...byOwner].map(([owner, text]) => ({ owner, text: text.replace(/\s+/g, " ") }))
+}
+
+function firstEmoji(text) {
+	const chars = [...text]
+	for (let i = 0; i < chars.length; i++) {
+		const cp = chars[i].codePointAt(0)
+		if (chars[i + 1] === "\uFE0F" && cp !== 0xfe0f) return chars[i] + chars[i + 1]
+		if ((cp >= 0x1f000 && cp <= 0x1faff) || (cp >= 0x2600 && cp <= 0x26ff) || DINGBAT_EMOJI.has(cp)) return chars[i]
+	}
+	return null
+}
+
+const isDigit = (ch) => ch >= "0" && ch <= "9"
+
+/** En dash allowed only when both neighbors (one optional space) are digits. */
+function badEnDash(text) {
+	for (let at = text.indexOf(EN_DASH); at !== -1; at = text.indexOf(EN_DASH, at + 1)) {
+		const before = text[at - 1] === " " ? text[at - 2] : text[at - 1]
+		const after = text[at + 1] === " " ? text[at + 2] : text[at + 1]
+		if (!isDigit(before ?? "") || !isDigit(after ?? "")) return at
+	}
+	return -1
+}
+
+const stripNumbering = (text) => text.replace(HEADING_NUMBER, "").trim()
+
+function headings(ctx, max) {
+	return ctx.elements.filter(({ node }) => /^h[1-6]$/.test(node.tag) && Number(node.tag[1]) <= max).map(({ node }) => node)
+}
+
+/** Citation markers need no stripping: an element carrying one is skipped before this runs. */
+function claimIn(text) {
+	let rest = text
+	for (const re of NOT_CLAIMS) rest = rest.replace(re, " ")
+	for (const re of CLAIMS) {
+		const match = re.exec(rest)
+		if (match) return match[0].trim()
+	}
+	return null
+}
+
+function numberCandidates(ctx) {
+	const { closest, classTokens, descendants } = ctx.util
+	return ctx.elements.filter(({ node, scope }) => {
+		if (node.tag !== "p" && node.tag !== "li") return false
+		if (node.tag === "li" && descendants(node).some((child) => child.tag === "p" || child.tag === "li")) return false
+		const kind = ctx.kindOf(scope)
+		if (kind === "closing" || kind === "sources") return false
+		return !closest(node, (cur) => NUMBER_CONTAINERS.has(cur.tag) || classTokens(cur).includes("fig"))
+	})
+}
+
+export const textGates = [
+	{
+		codes: ["korean_no_keep_all"],
+		run(ctx) {
+			const syllables = ctx.texts.reduce((sum, entry) => sum + (entry.node.text.match(HANGUL)?.length ?? 0), 0)
+			if (syllables < MIN_HANGUL) return []
+			if ([...ctx.styleBlocks, ...ctx.styleAttrs].some((entry) => KEEP_ALL.test(entry.css))) return []
+			return [ctx.defect("korean_no_keep_all", ctx.body, `${syllables} Hangul syllables in prose and no "word-break: keep-all" in any style block or style attribute`)]
+		},
+	},
+	{
+		codes: ["emoji_in_prose"],
+		run(ctx) {
+			const defects = []
+			for (const { owner, text } of ownerTexts(ctx, () => true)) {
+				const emoji = firstEmoji(text)
+				if (emoji) defects.push(ctx.defect("emoji_in_prose", owner, `emoji "${emoji}" in <${owner.tag}>: "${snippet(text, text.indexOf(emoji))}"`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["em_dash_in_prose", "en_dash_in_prose"],
+		run(ctx) {
+			const defects = []
+			const inScope = (entry) => !entry.cell && ctx.kindOf(entry.scope) !== "sources"
+			for (const { owner, text } of ownerTexts(ctx, inScope)) {
+				const em = text.indexOf(EM_DASH)
+				if (em !== -1) defects.push(ctx.defect("em_dash_in_prose", owner, `em dash "${EM_DASH}" in <${owner.tag}>: "${snippet(text, em)}"`))
+				const en = badEnDash(text)
+				if (en !== -1) defects.push(ctx.defect("en_dash_in_prose", owner, `en dash "${EN_DASH}" outside a numeric range in <${owner.tag}>: "${snippet(text, en)}"`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["heading_too_long"],
+		run(ctx) {
+			const defects = []
+			for (const node of headings(ctx, 4)) {
+				const text = stripNumbering(proseText(node))
+				const hangul = /[\uAC00-\uD7A3]/.test(text)
+				const size = hangul ? [...text].length : text.split(/\s+/).filter(Boolean).length
+				if (size > (hangul ? MAX_HEADING_HANGUL : MAX_HEADING_WORDS)) {
+					defects.push(ctx.defect("heading_too_long", node, `<${node.tag}> "${text}" is ${size} ${hangul ? "characters (> 26)" : "words (> 12)"}`))
+				}
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["heading_generic"],
+		run(ctx) {
+			const defects = []
+			for (const node of headings(ctx, 3)) {
+				const text = stripNumbering(proseText(node))
+				if (GENERIC.has(text.toLowerCase().replace(/[.:]+$/, ""))) defects.push(ctx.defect("heading_generic", node, `generic <${node.tag}> "${text}"`))
+			}
+			return defects
+		},
+	},
+	{
+		codes: ["unsourced_number"],
+		run(ctx) {
+			const defects = []
+			for (const { node } of numberCandidates(ctx)) {
+				if (defects.length >= MAX_UNSOURCED) break
+				const text = proseText(node)
+				if (LINEAGE_TOKEN.test(text) || ctx.util.hasCitation(node)) continue
+				if (node.attrs["data-lineage"] !== undefined || ctx.util.descendants(node).some((child) => child.attrs["data-lineage"] !== undefined)) continue
+				const claim = claimIn(text)
+				if (claim) defects.push(ctx.defect("unsourced_number", node, `number "${claim}" without a lineage tag or citation: "${snippet(text, text.indexOf(claim))}"`))
+			}
+			return defects
+		},
+	},
+]