oh-my-opencode 5.1.51 → 5.1.55

package/dist/skills/frontend/scripts/detect/rules/copy/numbered-section-labels.test.ts

@@ -0,0 +1,58 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot, type NodeSpec } from "../../testing/build-snapshot"
+import { numberedSectionLabels } from "./numbered-section-labels"
+
+const section = (id: string, text: string, style: Readonly<Record<string, string>> = {}): NodeSpec => ({
+	tag: "section", children: [
+		{ id, tag: "span", text, style: { "font-size": "11px", "font-family": "monospace", ...style } },
+		{ tag: "h2", text: `Section ${id}`, style: { "font-size": "28px" } },
+	],
+})
+const flagged = (nodes: readonly NodeSpec[]) => numberedSectionLabels.check({ snapshot: buildSnapshot(nodes), config: {} }).map((hit) => hit.element?.selector)
+
+test("#given distinct tiny indices and false positive shapes #then only styled section numbers report", () => {
+	expect(flagged([
+		section("first", "01"), section("second", "02 / ROLLOUT"),
+		section("large", "03", { "font-size": "16px" }),
+		section("plain", "12 · minute read", { "font-size": "12px", "font-family": "Georgia", color: "rgb(100, 100, 100)" }),
+		section("step", "Step 6"), section("single", "7"), section("rank", "#1 Rated"), section("over-limit", "41"),
+		{ tag: "nav", children: [section("navigation", "08")] },
+		{ tag: "ol", children: [section("list", "09")] },
+		{ tag: "article", style: { "background-color": "rgb(240, 240, 240)" }, children: [section("card", "10")] },
+	])).toEqual(["#first", "#second"])
+})
+
+test("#given a single index or repeated equal indices #then no section scaffold is inferred", () => {
+	expect(flagged([section("first", "01"), section("second", "02")])).toEqual(["#first", "#second"])
+	expect(flagged([section("only", "01")])).toEqual([])
+	expect(flagged([section("first", "01"), section("same", "01")])).toEqual([])
+})
+
+test("#given wrapper labels and large headings #then relative label sizing follows the actual text node", () => {
+	const wrapped = (id: string, text: string): NodeSpec => ({
+		children: [
+			{ children: [{ id, tag: "span", text, style: { "font-family": "monospace", "font-size": "15px" } }] },
+			{ children: [{ children: [{ tag: "h3", text: "Large feature", style: { "font-size": "44px" } }] }] },
+		],
+	})
+	const snapshot = buildSnapshot([wrapped("first", "01"), wrapped("second", "02"), section("too-large", "03", { "font-size": "17px" })])
+	expect(numberedSectionLabels.check({ snapshot, config: {} }).map((hit) => hit.snippet.split(" / ")[0])).toEqual(["01", "02"])
+})
+
+test("#given hash sections bare articles and hidden labels #then ranks cards and hidden scaffolds pass", () => {
+	expect(flagged([
+		{ tag: "article", children: [section("first", "#1 Connect")] },
+		{ tag: "article", children: [section("second", "#2 Remember")] },
+		{ style: { display: "none" }, children: [section("hidden", "03")] },
+		{ tag: "a", children: [{ tag: "article", children: [section("linked-card", "04")] }] },
+		section("rank", "#2 Best seller"),
+	])).toEqual(["#first", "#second"])
+})
+
+test("#given same-surface articles and page-scale frames #then only real cards are exempt", () => {
+	expect(flagged([
+		{ tag: "article", style: { "background-color": "rgb(255, 255, 255)" }, children: [section("same-surface", "01")] },
+		{ tag: "article", rect: { height: 2000 }, style: { "background-color": "rgb(240, 240, 240)" }, children: [section("page-frame", "02")] },
+		{ tag: "article", style: { "background-color": "rgb(240, 240, 240)" }, children: [section("card", "03")] },
+	])).toEqual(["#same-surface", "#page-frame"])
+})

package/dist/skills/frontend/scripts/detect/rules/copy/numbered-section-labels.ts

@@ -0,0 +1,34 @@
+import { descendants } from "../../core/page"
+import type { PageRule } from "../../rule"
+import { labelBefore, labelContext, labelType, parsedIndex, styledLabel } from "./support/numbered-label"
+
+export const numberedSectionLabels: PageRule = {
+	meta: {
+		id: "numbered-section-labels", name: "Tiny numbered section labels", category: "slop", severity: "advisory", engine: "page",
+		description: "Multiple headings carry tiny styled numeric indices that add scaffolding rather than information.",
+		fixHint: "Remove decorative section numbers or make necessary numbering part of the heading.",
+	},
+	check: ({ snapshot }) => {
+		const seen = new Set<number>()
+		const candidates = snapshot.elements.flatMap((heading) => {
+			if (!["h2", "h3", "h4"].includes(heading.tag) || heading.text.length < 3) return []
+			const label = labelBefore(snapshot, heading)
+			if (!label || seen.has(label.index) || !labelContext(snapshot, heading, label) || !labelContext(snapshot, label, heading)
+				|| !["span", "p", "div", "small", "em", "strong", "b"].includes(label.tag)) return []
+			const text = (label.ownText || label.text).replace(/\s+/g, " ").trim()
+			const index = parsedIndex(text)
+			if (index === null || !styledLabel(labelType(snapshot, label), heading)) return []
+			if ([...descendants(snapshot, label)].some((el) => ["img", "picture", "video", "canvas"].includes(el.tag)
+				|| el.tag === "svg" && snapshot.elements[el.parent ?? -1]?.ownText.match(/^\d{2}$/))) return []
+			seen.add(label.index)
+			return [{ label, heading, text, index }]
+		})
+		const hashWords = candidates.filter((c) => c.text.startsWith("#")).map((c) => /^#\d+\s+(\S+)/.exec(c.text)?.[1]?.toLowerCase())
+		const matchingHashes = hashWords.length >= 2 && hashWords[0] !== undefined && hashWords.every((w) => w === hashWords[0])
+		const filtered = matchingHashes ? candidates.filter((c) => !c.text.startsWith("#")) : candidates
+		if (filtered.length < 2 || new Set(filtered.map((c) => c.index)).size < 2) return []
+		return filtered.map(({ label, heading, text }) => ({
+			element: label, message: `${filtered.length} tiny numeric labels beside section headings`, snippet: `${text.slice(0, 24)} / ${heading.text.slice(0, 60)}`,
+		}))
+	},
+}

package/dist/skills/frontend/scripts/detect/rules/copy/repeated-container-text.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot, type NodeSpec } from "../../testing/build-snapshot"
+import { repeatedContainerText } from "./repeated-container-text"
+
+const card = (id: string, children: readonly NodeSpec[]): NodeSpec => ({
+	id, style: { "border-top-width": "1px", "border-right-width": "1px", "border-bottom-width": "1px", "border-top-left-radius": "10px" }, children,
+})
+const slots = (text: string): readonly NodeSpec[] => [
+	{ tag: "span", text }, { tag: "em", text }, { tag: "strong", text },
+]
+const flagged = (nodes: readonly NodeSpec[]) => repeatedContainerText.check({ snapshot: buildSnapshot(nodes), config: {} }).map((hit) => hit.element?.selector)
+
+test("#given repeated text in distinct slots versus templated rows #then only redundant slots report", () => {
+	expect(flagged([
+		card("flag", slots("Suspended")),
+		card("parallel", Array.from({ length: 3 }, () => ({ tag: "div", attributes: { class: "row" }, children: [{ tag: "span", text: "Suspended" }] }))),
+		card("short", slots("Off")), card("numbers", slots("2026")), card("two", slots("Unavailable").slice(0, 2)),
+		card("table", [{ tag: "table", children: slots("Suspended") }]),
+		card("nav", [{ tag: "nav", children: slots("Suspended") }]),
+		card("grid", [{ attributes: { role: "grid" }, children: slots("Suspended") }]),
+	])).toEqual(["#flag"])
+})
+
+test("#given nested cards and unbounded containers #then the nearest bounded card owns its repeats", () => {
+	expect(flagged([
+		card("outer", [card("inner", slots("Unavailable"))]),
+		{ id: "unbounded", children: slots("Unavailable") },
+		...["one", "two", "three"].map((id) => card(id, [{ tag: "span", text: "Standby mode" }])),
+	])).toEqual(["#inner"])
+})
+
+test("#given carousel id classes and clipped slides #then parked or structurally identical copies pass", () => {
+	const slides = (generated: boolean): readonly NodeSpec[] => [0, 1, 2].map((n) => ({
+		attributes: { class: generated ? `slide post-${43000 + n}` : `slide slot-${n}` },
+		rect: { x: n * 320, width: 320 },
+		children: [{ tag: "a", text: "Servidor VPS", rect: { x: n * 320, width: 100 } }],
+	}))
+	expect(flagged([
+		card("visible", slots("Servidor VPS")),
+		card("generated", slides(true)),
+		card("parked", [{ style: { "overflow-x": "hidden" }, rect: { width: 320 }, children: slides(false) }]),
+	])).toEqual(["#visible"])
+})

package/dist/skills/frontend/scripts/detect/rules/copy/repeated-container-text.ts

@@ -0,0 +1,56 @@
+import { ancestors, descendants, px, styleOf } from "../../core/page"
+import { parseColor } from "../../core/color"
+import type { PageHit, PageRule } from "../../rule"
+import type { ElementSnapshot, PageSnapshot } from "../../types"
+import { lineage, paintedText } from "./support/page-text"
+
+const skip = (snapshot: PageSnapshot, el: ElementSnapshot): boolean => lineage(snapshot, el).some((a) =>
+	["table", "select", "datalist", "nav", "menu"].includes(a.tag)
+	|| ["navigation", "menu", "menubar", "listbox", "grid", "tablist", "radiogroup"].includes(a.attributes["role"] ?? "")
+	|| a.attributes["aria-hidden"] === "true")
+
+export const repeatedContainerText: PageRule = {
+	meta: {
+		id: "repeated-container-text", name: "Same text repeated inside one container", category: "quality", severity: "warning", engine: "page",
+		description: "One card repeats a short string in at least three different structural slots.",
+		fixHint: "State the status once; remove redundant labels from the other slots.",
+	},
+	check: ({ snapshot }) => {
+		const containers = snapshot.elements.filter((el) => {
+			if (!["div", "section", "article", "aside", "main", "figure", "form", "fieldset", "details", "li"].includes(el.tag) || skip(snapshot, el)) return false
+			const shadow = styleOf(el, "box-shadow")
+			const border = ["top", "right", "bottom", "left"].filter((side) => (px(styleOf(el, `border-${side}-width`)) ?? 0) >= 1).length >= 3
+			const radius = (px(styleOf(el, "border-top-left-radius")) ?? 0) > 0
+			const background = (parseColor(styleOf(el, "background-color"))?.a ?? 0) > 0.1
+			return (shadow !== "" && shadow !== "none" || border) && (radius || background)
+		})
+		const containerIds = new Set(containers.map((el) => el.index))
+		const hits: PageHit[] = []
+		for (const container of containers) {
+			if (!paintedText(snapshot, container)) continue
+			const nodes = [...descendants(snapshot, container)]
+			if (nodes.length > 250) continue
+			const groups = new Map<string, string[]>()
+			for (const el of nodes) {
+				const path = [...ancestors(snapshot, el)]
+				const owned = path.slice(0, path.findIndex((a) => a.index === container.index))
+				if (owned.some((a) => containerIds.has(a.index)) || skip(snapshot, el) || !paintedText(snapshot, el)) continue
+				if (/icon|material-symbols|(?:^|\s)fa[srlbd]?(?:\s|-|$)/i.test(el.attributes["class"] ?? "")) continue
+				const text = el.ownText.trim()
+				if (text.length < 4 || text.length > 48 || !/[a-zA-Z]/.test(text)) continue
+				const signature = [el, ...owned].map((a) => {
+					const classes = (a.attributes["class"] ?? "").split(/\s+/).filter((c) => c !== ""
+						&& !c.split(/[-_]/).some((part) => part.length >= 4 && /^[a-f\d]+$/i.test(part) && /\d/.test(part))).sort().join(".")
+					return `${a.tag}${classes === "" ? "" : `.${classes}`}`
+				}).join(">")
+				const signatures = groups.get(text) ?? []
+				signatures.push(signature)
+				groups.set(text, signatures)
+			}
+			for (const [text, signatures] of groups) if (signatures.length >= 3 && new Set(signatures).size >= 3) hits.push({
+				element: container, message: `Same text rendered ${signatures.length} times in distinct slots`, snippet: text.slice(0, 40),
+			})
+		}
+		return hits
+	},
+}

package/dist/skills/frontend/scripts/detect/rules/copy/script-error.test.ts

@@ -0,0 +1,48 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot } from "../../testing/build-snapshot"
+import { scriptError } from "./script-error"
+import { lintSnapshot } from "../../lint"
+
+test("#given captured errors duplicates and blanks #then only three distinct errors report", () => {
+	const check = (scriptErrors: readonly string[]) => scriptError.check({ snapshot: buildSnapshot([], { scriptErrors }), config: {} })
+	const hits = check(["", "TypeError: cart is undefined", "TypeError: cart is undefined", "SyntaxError: invalid token", "ReferenceError: missing", "Error: fourth"])
+	expect(hits.map((hit) => hit.snippet)).toEqual(["TypeError: cart is undefined", "SyntaxError: invalid token", "ReferenceError: missing"])
+	expect(check([])).toHaveLength(0)
+})
+test("#given recoverable media hydration and ad-tech errors #then lint preserves advisory severities and project overrides", () => {
+	const snapshot = buildSnapshot([], { scriptErrors: [
+		"Minified React error #418", "AbortError: The play() request was interrupted",
+		"adsbygoogle failed", "TypeError: cart missing",
+	] })
+	expect(lintSnapshot(snapshot, { rules: [scriptError] }).map(hit => hit.severity)).toEqual([
+		"advisory", "advisory", "advisory", "error",
+	])
+	expect(lintSnapshot(snapshot, { rules: [scriptError], config: { rules: { "script-error": "warning" } } }).map(hit => hit.severity))
+		.toEqual(["warning", "warning", "warning", "warning"])
+})
+
+test("#given recoverable errors before application crashes #then each class retains separate slots", () => {
+	const snapshot = buildSnapshot([], { scriptErrors: [
+		"Minified React error #418", "Minified React error #419", "Minified React error #422", "Minified React error #423",
+		"adsbygoogle 1", "adsbygoogle 2", "adsbygoogle 3", "adsbygoogle 4",
+		"Minified React error #4180", "AbortError: fetch aborted", "TypeError: cart missing", "Error: fourth",
+	] })
+	const hits = scriptError.check({ snapshot, config: {} })
+	expect(hits).toHaveLength(9)
+	expect(hits.filter((hit) => hit.message === "Uncaught page script error").map((hit) => hit.snippet)).toEqual([
+		"Minified React error #4180", "AbortError: fetch aborted", "TypeError: cart missing",
+	])
+	expect(scriptError.check({ snapshot: buildSnapshot([]), config: {} })).toHaveLength(0)
+})
+
+test("#given a renderer that could not install the error probe #then one advisory says errors were not captured", () => {
+	const snapshot = buildSnapshot([], { scriptErrorsCaptured: false })
+	expect(lintSnapshot(snapshot, { rules: [scriptError] }).map((f) => [f.severity, f.location.kind])).toEqual([["advisory", "page"]])
+	expect(lintSnapshot(buildSnapshot([]), { rules: [scriptError] })).toHaveLength(0)
+})
+
+test("#given a project override that raises script-error #then the not-captured notice stays advisory and off still drops it", () => {
+	const snapshot = buildSnapshot([], { scriptErrorsCaptured: false })
+	expect(lintSnapshot(snapshot, { rules: [scriptError], config: { rules: { "script-error": "error" } } }).map((f) => f.severity)).toEqual(["advisory"])
+	expect(lintSnapshot(snapshot, { rules: [scriptError], config: { rules: { "script-error": "off" } } })).toHaveLength(0)
+})

package/dist/skills/frontend/scripts/detect/rules/copy/script-error.ts

@@ -0,0 +1,38 @@
+import type { PageHit, PageRule } from "../../rule"
+
+export const scriptError: PageRule = {
+	meta: {
+		id: "script-error", name: "Uncaught script error on load", category: "quality", severity: "error", engine: "page",
+		description: "An uncaught exception or rejected promise occurred while the page loaded.",
+		fixHint: "Fix the failing script or handle its rejected promise, then verify the page loads without uncaught errors.",
+	},
+	check: ({ snapshot }) => {
+		if (!snapshot.scriptErrorsCaptured) {
+			return [{
+				element: null,
+				message: "Script errors were not captured: this renderer could not install its error probe before the page's scripts",
+				snippet: snapshot.url,
+				severity: "advisory",
+				severityFixed: true,
+			}]
+		}
+		const counts = new Map<string, number>()
+		const hits: PageHit[] = []
+		for (const error of new Set(snapshot.scriptErrors)) {
+			const hydration = /Minified React error #(418|419|422|423|425)(?!\d)/.test(error)
+			const media = error.includes("AbortError") && error.includes("The play() request was interrupted")
+			const adTech = /browsingTopics|joinAdInterestGroup|runAdAuction|adsbygoogle|_prebidjs/.test(error)
+			const kind = adTech ? "ad-tech" : hydration || media ? "recoverable" : "uncaught"
+			const count = counts.get(kind) ?? 0
+			if (error.trim() === "" || count >= 3) continue
+			counts.set(kind, count + 1)
+			hits.push({
+				element: null,
+				message: kind === "uncaught" ? "Uncaught page script error" : `Page script error (${kind})`,
+				snippet: error,
+				severity: kind === "uncaught" ? "error" : "advisory",
+			})
+		}
+		return hits
+	},
+}

package/dist/skills/frontend/scripts/detect/rules/copy/skipped-heading.test.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot } from "../../testing/build-snapshot"
+import { skippedHeading } from "./skipped-heading"
+
+test("#given a skipped rank followed by a descending rank #then only the forward skip reports", () => {
+	const snapshot = buildSnapshot([
+		{ tag: "h1", text: "Title" }, { tag: "h3", id: "skip", text: "Section" }, { tag: "h2", id: "back", text: "Next section" },
+		{ tag: "h3", id: "ordinary", text: "Subsection" },
+	])
+	expect(skippedHeading.check({ snapshot, config: {} }).map((hit) => hit.element?.selector)).toEqual(["#skip"])
+})
+
+test("#given hidden panels and screen reader headings #then hidden panels leave the outline", () => {
+	const snapshot = buildSnapshot([
+		{ tag: "h1", text: "Title" },
+		{ style: { display: "none" }, children: [{ tag: "h4", id: "hidden", text: "Closed menu" }] },
+		{ tag: "h2", text: "Section" },
+		{ style: { visibility: "hidden" }, children: [{ tag: "h5", id: "hidden-widget", text: "Widget" }] },
+		{ tag: "h4", id: "sr", text: "Screen reader title", attributes: { class: "sr-only" }, rect: { width: 1, height: 1 } },
+		{ tag: "h5", id: "faded", text: "Reveal", style: { opacity: "0" } },
+	])
+	expect(skippedHeading.check({ snapshot, config: {} }).map((hit) => hit.element?.selector)).toEqual(["#sr"])
+})
+
+test("#given footer columns and closing calls to action #then later internal skips still report", () => {
+	const snapshot = buildSnapshot([
+		{ tag: "h1", text: "Title" }, { tag: "h2", text: "Last section" },
+		{ tag: "footer", children: [
+			{ tag: "h2", text: "Join us" }, { tag: "h4", id: "column", text: "Company" },
+			{ tag: "h6", id: "footer-skip", text: "Bad nested title" },
+		] },
+		{ tag: "h2", text: "Content resumes" }, { tag: "h4", id: "content-skip", text: "Bad content title" },
+	])
+	expect(skippedHeading.check({ snapshot, config: {} }).map((hit) => hit.element?.selector)).toEqual(["#footer-skip", "#content-skip"])
+})
+
+test("#given a declared mockup beside real content #then only the real content enters the outline", () => {
+	const check = (hidden: string) => skippedHeading.check({ snapshot: buildSnapshot([
+		{ tag: "h1", text: "The product overview" },
+		{ tag: "p", text: "This paragraph explains the actual product and its concrete capabilities for a visitor. ".repeat(8) },
+		{ tag: "h2", text: "Content section" },
+		{ attributes: { "aria-hidden": hidden }, rect: { width: 320, height: 180 }, children: [
+			{ tag: "h4", id: "mock-title", text: "Window" }, { tag: "span", text: "Inbox" }, { tag: "span", text: "Messages" },
+		] },
+		{ tag: "h3", text: "Content subsection" },
+	]), config: {} })
+	expect(check("true")).toHaveLength(0)
+	expect(check("false").map((hit) => hit.element?.selector)).toEqual(["#mock-title"])
+})

package/dist/skills/frontend/scripts/detect/rules/copy/skipped-heading.ts

@@ -0,0 +1,81 @@
+import { childrenOf, descendants, headingLevel, parentOf } from "../../core/page"
+import type { PageHit, PageRule } from "../../rule"
+import { displayed, lineage } from "./support/page-text"
+
+export const skippedHeading: PageRule = {
+	meta: {
+		id: "skipped-heading", name: "Skipped heading level", category: "quality", severity: "warning", engine: "page",
+		description: "A heading jumps over a level in the visible content outline.",
+		fixHint: "Use the next heading level and style it independently of its semantic rank.",
+	},
+	check: ({ snapshot }) => {
+		const hits: PageHit[] = []
+		let previous = 0
+		let previousText = ""
+		let previousFooter: number | undefined
+		let previousOpensFooter = false
+		const squash = (text: string): string => text.replace(/\s/g, "")
+		const sourceTags = ["script", "style", "noscript", "template"]
+		const textChars = snapshot.elements.filter((el) => displayed(snapshot, el) && el.style["visibility"] !== "hidden" && !sourceTags.includes(el.tag))
+			.reduce((total, el) => total + [...squash(el.ownText)].length, 0)
+		const hidden = (el: typeof snapshot.elements[number]): boolean =>
+			el.attributes["inert"] !== undefined || el.attributes["aria-hidden"]?.trim().toLowerCase() === "true"
+		const modals = snapshot.elements.filter((el) =>
+			(el.attributes["aria-modal"] === "true" || ["dialog", "alertdialog"].includes(el.attributes["role"] ?? "")
+				|| el.tag === "dialog" && el.attributes["open"] !== undefined)
+			&& !hidden(el) && displayed(snapshot, el) && el.rect.width > 0 && el.rect.height > 0 && el.style["visibility"] !== "hidden")
+		const mockups = new Set(snapshot.elements.filter((root) => {
+			if (!hidden(root) || root.rect.width < 120 || root.rect.height < 80) return false
+			if (["html", "body", "main", "header", "footer", "nav", "aside", "section", "article", "form", "dialog", "li", "tr", "td", "th", "tbody", "thead", "table", "details", "summary"].includes(root.tag)) return false
+			if ((root.attributes["role"] ?? "").trim().split(/\s+/).some((r) => r !== "" && !["presentation", "none", "img", "figure", "group"].includes(r))) return false
+			if (root.attributes["aria-modal"] !== undefined || root.attributes["data-aria-hidden"] !== undefined || ["fixed", "sticky"].includes(root.style["position"] ?? "")) return false
+			const names = `${root.attributes["class"] ?? ""} ${root.attributes["id"] ?? ""}`
+			if (/(?:^|[\s_-])(clones?|cloned|copy|duplicate|dup|carousel|embla|flicking|glide|keen|slick|slides?|slider|splide|swiper|marquee|ticker|menu|submenu|dropdown|popup|popover|modal|drawer|dialog|tooltip|toast|offcanvas|overlay|nav|navbar|navigation|panel|tab|tabpanel|accordion|collapse|collapsible|intro|splash|loader|preloader|loading|banner|cookies?|consent|sidebar|sidenav|toc)(?:$|[\s_-])/i.test(names)) return false
+			const ancestors = lineage(snapshot, root).slice(1)
+			if (ancestors.some((a) => ["h1", "h2", "h3", "h4", "h5", "h6", "p", "a", "button", "label", "summary", "legend", "caption", "figcaption", "blockquote", "q"].includes(a.tag))) return false
+			const nodes = [root, ...descendants(snapshot, root)]
+			if (nodes.length > 3000 || nodes.some((el) => el.tag === "h1")) return false
+			const runs = nodes.filter((el) => displayed(snapshot, el) && el.style["visibility"] !== "hidden"
+				&& !sourceTags.includes(el.tag) && squash(el.ownText) !== "")
+			const chars = runs.reduce((total, el) => total + [...squash(el.ownText)].length, 0)
+			if (runs.length < 3 || textChars === 0 || chars * 2 >= textChars) return false
+			const fields = nodes.filter((el) => ["input", "select", "textarea"].includes(el.tag) && !(el.tag === "input" && el.attributes["type"]?.toLowerCase() === "hidden"))
+			const linkedRuns = runs.filter((el) => lineage(snapshot, el).some((a) => a.tag === "a" && (a.attributes["href"] ?? "").trim() !== ""))
+			if (fields.length >= 2 || fields.length > 0 && nodes.some((el) => el.tag === "label") || linkedRuns.length * 2 >= runs.length) return false
+			if (modals.some((modal) => !nodes.includes(modal) && !lineage(snapshot, root).includes(modal))) return false
+			const text = squash(root.text)
+			if (text !== "" && ancestors.some((a) => squash(a.attributes["aria-label"] ?? "").includes(text))) return false
+			const parent = parentOf(snapshot, root)
+			const peers = parent ? childrenOf(snapshot, parent).filter((el) => el.index !== root.index) : []
+			const classes = (root.attributes["class"] ?? "").split(/\s+/).filter(Boolean)
+			return !peers.some((peer) => {
+				const peerClasses = (peer.attributes["class"] ?? "").split(/\s+/).filter(Boolean)
+				const sameShape = peer.tag === root.tag && (classes.length === 0) === (peerClasses.length === 0) && classes.every((c) => peerClasses.includes(c))
+				const shown = displayed(snapshot, peer) && peer.style["visibility"] !== "hidden" && !hidden(peer)
+				if (shown && (sameShape && peer.rect.width > 0 && peer.rect.height > 0 || text !== "" && squash(peer.text) === text)) return true
+				const alternative = peer.rect.width <= 1 || peer.rect.height <= 1 || /sr-only|visually-?hidden|screen-?reader|a11y-hidden|hidden-visually/i.test(peer.attributes["class"] ?? "")
+				return shown && alternative && peer.text.trim() !== "" && !/\b(demo|demonstration|illustrat\w*|interface|screen ?shots?|mock-?ups?|graphic|animation|animated|preview|image|video|visual|diagram|depict\w*|shows|showing|displayed)\b/i.test(peer.text)
+			})
+		}).map((el) => el.index))
+		for (const el of snapshot.elements) {
+			const level = headingLevel(el)
+			if (level === null || !displayed(snapshot, el) || el.rect.width <= 0 || el.rect.height <= 0) continue
+			const path = lineage(snapshot, el)
+			if (path.some((a) => mockups.has(a.index))) continue
+			if (path.some((a) => a.style["visibility"] === "hidden" || (a.tag === "dialog" && a.attributes["open"] === undefined))) continue
+			const footer = path.find((a) => a.tag === "footer" || a.attributes["role"] === "contentinfo" || a.attributes["id"] === "footer")?.index
+			const opensFooter = footer !== undefined && footer !== previousFooter
+			const intoFooter = footer !== undefined && (opensFooter || previousOpensFooter)
+			const skips = previous > 0 && level > previous + 1
+			if (skips && !intoFooter) hits.push({
+				element: el, message: `h${previous} followed by h${level}; missing h${previous + 1}`,
+				snippet: `${previousText.slice(0, 60)} / ${el.text.slice(0, 60)}`,
+			})
+			previousOpensFooter = opensFooter && previous > 0 && !skips
+			previousFooter = footer
+			previous = level
+			previousText = el.text
+		}
+		return hits
+	},
+}

package/dist/skills/frontend/scripts/detect/rules/copy/support/numbered-label.ts

@@ -0,0 +1,94 @@
+import { childrenOf, descendants, effectiveBackground, fontSizePx, parentOf, px, styleOf } from "../../../core/page"
+import { parseColor } from "../../../core/color"
+import { parseShadow } from "../../../core/shadow"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+import { displayed, lineage } from "./page-text"
+
+export const parsedIndex = (text: string): number | null => {
+	if (text.length > 40) return null
+	const hash = /^#([0-9]{1,2})(?: [^ ].*)?$/.exec(text)
+	if (hash && /^#\d+ (rated|ranked|rank|best|top|in|pick|choice|overall|seller|bestseller|selling|voted|place|trending)\b/i.test(text)) return null
+	const match = hash ?? /^([0-9]{2})$/.exec(text) ?? /^([0-9]{1,2})\s*[^0-9A-Za-z_\s]\s*\S/.exec(text)
+	return match?.[1] !== undefined && Number(match[1]) <= 40 ? Number(match[1]) : null
+}
+
+export const labelBefore = (snapshot: PageSnapshot, heading: ElementSnapshot): ElementSnapshot | null => {
+	let current = heading
+	for (let level = 0; level <= 4; level++) {
+		const parent = parentOf(snapshot, current)
+		if (!parent) return null
+		const siblings = childrenOf(snapshot, parent)
+		const label = siblings[siblings.findIndex((s) => s.index === current.index) - 1]
+		if (label) {
+			const l = label.rect
+			const h = heading.rect
+			if (level > 1 && (l.width <= 0 || l.height <= 0 || h.width <= 0 || h.height <= 0 || l.y >= h.y + h.height
+				|| Math.max(h.y - l.y - l.height, h.x - l.x - l.width, 0) > 96)) return null
+			return label
+		}
+		if (["body", "html"].includes(parent.tag)) return null
+		current = parent
+	}
+	return null
+}
+
+export const labelType = (snapshot: PageSnapshot, label: ElementSnapshot): ElementSnapshot => {
+	let el = label
+	for (let level = 0; level < 3; level++) {
+		if (el.ownText !== "") return el
+		const children = childrenOf(snapshot, el).filter((c) => c.text.trim() !== "")
+		const only = children[0]
+		if (children.length !== 1 || !only) return el
+		el = only
+	}
+	return el
+}
+
+const drawsBox = (snapshot: PageSnapshot, el: ElementSnapshot): boolean => {
+	const parent = parentOf(snapshot, el)
+	const under = parent ? effectiveBackground(snapshot, parent) : { r: 255, g: 255, b: 255 }
+	const fill = effectiveBackground(snapshot, el)
+	const image = styleOf(el, "background-image")
+	const border = ["top", "right", "bottom", "left"].filter((side) =>
+		(px(styleOf(el, `border-${side}-width`)) ?? 0) >= 0.5
+		&& !["none", "hidden", ""].includes(styleOf(el, `border-${side}-style`))
+		&& (parseColor(styleOf(el, `border-${side}-color`))?.a ?? 0) > 0).length >= 3
+	return Math.max(Math.abs(fill.r - under.r), Math.abs(fill.g - under.g), Math.abs(fill.b - under.b)) > 3
+		|| image !== "" && image !== "none" || border
+		|| parseShadow(styleOf(el, "box-shadow")).some((layer) => layer.color.a >= 0.03
+			&& (layer.x !== 0 || layer.y !== 0 || layer.blur > 0 || layer.spread !== 0))
+}
+
+export const labelContext = (snapshot: PageSnapshot, el: ElementSnapshot, partner: ElementSnapshot = el): boolean => {
+	const path = lineage(snapshot, el)
+	if (!displayed(snapshot, el) || path.some((a) => ["nav", "form", "table", "thead", "tbody", "tfoot", "figure", "figcaption", "ol", "ul", "li"].includes(a.tag)
+		|| a.attributes["role"] === "navigation" || a.attributes["aria-hidden"] === "true"
+		|| a.attributes["data-impeccable-allow-kickers"] !== undefined
+		|| /breadcrumb/i.test(`${a.attributes["class"] ?? ""} ${a.attributes["aria-label"] ?? ""}`))) return false
+	const context = path.find((a) => ["article", "button", "a", "li"].includes(a.tag) || ["listitem", "option"].includes(a.attributes["role"] ?? ""))
+	if (!context || context.rect.height > snapshot.viewport.height * 2 || !lineage(snapshot, partner).includes(context)) return true
+	if (context.tag !== "article") return false
+	const above = lineage(snapshot, context).slice(1)
+	if (above.some((a) => ["a", "button", "li"].includes(a.tag) || ["listitem", "option"].includes(a.attributes["role"] ?? ""))) return false
+	if (path.slice(1, path.findIndex((a) => a.index === context.index) + 1).some((a) =>
+		lineage(snapshot, partner).includes(a) && drawsBox(snapshot, a))) return false
+	let below = context
+	for (const up of above.slice(0, 3)) {
+		if (up.tag === "body") break
+		const otherArticle = [...descendants(snapshot, up)].some((a) => a.tag === "article" && a.index !== context.index)
+		if (!otherArticle && drawsBox(snapshot, up)) return false
+		if (up.children.length !== 1 || up.children[0] !== below.index) break
+		below = up
+	}
+	return true
+}
+
+export const styledLabel = (label: ElementSnapshot, heading: ElementSnapshot): boolean => {
+	const size = fontSizePx(label)
+	const headingSize = fontSizePx(heading)
+	if (size <= 0 || size > Math.max(13, Math.min(16, headingSize * 0.45)) || headingSize > 0 && headingSize < size * 1.3) return false
+	const color = parseColor(styleOf(label, "color"))
+	return /mono/i.test(styleOf(label, "font-family")) || Number(styleOf(label, "font-weight")) >= 600
+		|| (px(styleOf(label, "letter-spacing")) ?? 0) >= 0.5 || styleOf(label, "text-transform") === "uppercase"
+		|| (color !== null && Math.max(color.r, color.g, color.b) - Math.min(color.r, color.g, color.b) >= 40)
+}

package/dist/skills/frontend/scripts/detect/rules/copy/support/page-text.ts

@@ -0,0 +1,37 @@
+import { ancestors, isRendered, styleOf } from "../../../core/page"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+
+export const lineage = (snapshot: PageSnapshot, el: ElementSnapshot): readonly ElementSnapshot[] =>
+	[el, ...ancestors(snapshot, el)]
+
+export const displayed = (snapshot: PageSnapshot, el: ElementSnapshot): boolean =>
+	lineage(snapshot, el).every((a) => styleOf(a, "display") !== "none" && styleOf(a, "content-visibility") !== "hidden")
+
+export const visibleText = (snapshot: PageSnapshot, el: ElementSnapshot): boolean => {
+	if (!isRendered(snapshot, el) || !displayed(snapshot, el)) return false
+	return lineage(snapshot, el).every((a) => styleOf(a, "visibility") !== "hidden"
+		&& !(a.tag === "dialog" && a.attributes["open"] === undefined))
+}
+
+export const pageText = (snapshot: PageSnapshot): string =>
+	snapshot.elements.filter((el) => visibleText(snapshot, el) && !["script", "style", "template", "noscript"].includes(el.tag))
+		.map((el) => el.ownText).filter(Boolean).join(" ").replace(/\s+/g, " ").trim()
+
+export const paintedText = (snapshot: PageSnapshot, el: ElementSnapshot): boolean => {
+	if (!visibleText(snapshot, el)) return false
+	let left = el.rect.x
+	let top = el.rect.y
+	let right = left + el.rect.width
+	let bottom = top + el.rect.height
+	for (const a of ancestors(snapshot, el)) {
+		if (["hidden", "clip", "auto", "scroll"].includes(styleOf(a, "overflow-x"))) {
+			left = Math.max(left, a.rect.x)
+			right = Math.min(right, a.rect.x + a.rect.width)
+		}
+		if (["hidden", "clip", "auto", "scroll"].includes(styleOf(a, "overflow-y"))) {
+			top = Math.max(top, a.rect.y)
+			bottom = Math.min(bottom, a.rect.y + a.rect.height)
+		}
+	}
+	return right > left && bottom > top
+}

package/dist/skills/frontend/scripts/detect/rules/copy/theater-slop-phrase.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from "bun:test"
+import { buildSnapshot } from "../../testing/build-snapshot"
+import { theaterSlopPhrase } from "./theater-slop-phrase"
+
+test("#given dismissive framing and literal theaters #then only the closed vocabulary reports", () => {
+	const check = (text: string) => theaterSlopPhrase.check({ snapshot: buildSnapshot([{ text }]), config: {} })
+	for (const text of ["Security theater", "growth THEATER", "Accessibility theater"]) expect(check(text)).toHaveLength(1)
+	for (const text of ["Southern Theater Command", "The official theater", "A theater of operations", "security theatrical"]) expect(check(text)).toHaveLength(0)
+})
+
+test("#given framing split across inline elements #then rendered words still match", () => {
+	const check = (text: string) => theaterSlopPhrase.check({
+		snapshot: buildSnapshot([{ tag: "p", children: [{ tag: "span", text }, { tag: "em", text: "theater" }] }]), config: {},
+	})
+	expect(check("privacy")).toHaveLength(1)
+	expect(check("national")).toHaveLength(0)
+})

package/dist/skills/frontend/scripts/detect/rules/copy/theater-slop-phrase.ts

@@ -0,0 +1,21 @@
+import type { PageRule } from "../../rule"
+import { pageText } from "./support/page-text"
+
+const HEADS = [
+	"accessibility", "accountability", "agile", "alignment", "compliance", "diversity", "engagement", "governance", "growth",
+	"hiring", "hygiene", "innovation", "inclusion", "kindness", "leadership", "metrics", "privacy", "process", "productivity",
+	"quality", "safety", "security", "strategy", "sustainability", "transparency", "trust", "wellness",
+] as const
+
+export const theaterSlopPhrase: PageRule = {
+	meta: {
+		id: "theater-slop-phrase", name: "Theater framing copy", category: "slop", severity: "advisory", engine: "page",
+		description: "Calling a practice theater dismisses it without explaining the defect.",
+		fixHint: "Describe the missing behavior or evidence instead of dismissing it as theater.",
+	},
+	check: ({ snapshot }) => {
+		const match = [...pageText(snapshot).matchAll(/\b(\w+)\s+theater\b/gi)]
+			.find((m) => HEADS.some((head) => head === m[1]?.toLowerCase()))
+		return match ? [{ element: null, message: "Dismissive theater framing", snippet: match[0] }] : []
+	},
+}