oh-my-opencode 5.1.51 → 5.1.55

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/gradient-pattern.ts

@@ -0,0 +1,40 @@
+import { parseColor } from "../../../core/color"
+import { splitTop } from "./appearance"
+const position = (value: string): number | null => {
+	const token = value
+		.replace(/\s/g, "")
+		.replace(/^(?:calc\()+/, "")
+		.replace(/\)+$/, "")
+	const match = /^([-+]?[\d.]+)(%|deg|grad|turn|px)?$/.exec(token)
+	if (!match) return null
+	const n = Number(match[1])
+	if (n === 0) return 0
+	return match[2] === "%" ? n / 100 : match[2] === "deg" ? n / 360 : match[2] === "grad" ? n / 400 : match[2] === "turn" ? n : null
+}
+export function repeats(value: string): boolean {
+	for (const layer of splitTop(value)) {
+		const m = /^repeating-(linear|radial)-gradient\(([\s\S]*)\)$/i.exec(layer)
+		if (!m) continue
+		const stops = splitTop(m[2] ?? ""),
+			first = splitTop(stops[0] ?? "", /\s/),
+			token = first[0] ?? ""
+		if (token.includes("var(")) return true
+		const start =
+			parseColor(token) !== null ||
+			(/^(?:transparent|currentcolor|[a-z]+)$/i.test(token) && !/^(?:circle|ellipse|to|at|in|closest|farthest)/i.test(token))
+				? 0
+				: 1
+		if (stops.length < start + 2) return true
+		if (m[1]?.toLowerCase() === "radial" && start === 1) {
+			const prelude = (stops[0] ?? "").split(/\bat\b|\bin\b/)[0] ?? ""
+			if (/closest-|farthest-side|[0-9]/.test(prelude)) return true
+		}
+		const a = splitTop(stops[start] ?? "", /\s/),
+			b = splitTop(stops.at(-1) ?? "", /\s/)
+		if (b.length === 1 && b[0]?.includes("var(")) return true
+		const zero = a[1] === undefined || position(a[1]) === 0,
+			full = b.length === 1 || position(b.at(-1) ?? "") === 1
+		if (!(zero && full)) return true
+	}
+	return false
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/keyframes.ts

@@ -0,0 +1,134 @@
+import type { ComputedStyle, PageSnapshot } from "../../../types"
+import { splitTop } from "./appearance"
+export type Frame = Readonly<Record<string, string>>
+export type KeyframeStep = { readonly key: string; readonly declarations: Frame }
+export function keyframeSteps(s: PageSnapshot, name: string): readonly KeyframeStep[] | null {
+	const frames: KeyframeStep[] = []
+	let found = false
+	for (const css of s.cssText) {
+		const text = css.replace(/\/\*[\s\S]*?\*\//g, "")
+		for (const m of text.matchAll(/@(?:-webkit-)?keyframes\s+([\w-]+)\s*\{/g)) {
+			if (m[1] !== name) continue
+			found = true
+			let end = (m.index ?? 0) + m[0].length,
+				depth = 1
+			const start = end
+			while (end < text.length && depth > 0) {
+				if (text[end] === "{") depth++
+				if (text[end] === "}") depth--
+				end++
+			}
+			for (const step of text.slice(start, end - 1).matchAll(/([^{}]+)\{([^{}]*)\}/g)) {
+				const entries = (step[2] ?? "").split(";").flatMap((d) => {
+					const i = d.indexOf(":")
+					return i < 0 ? [] : [[d.slice(0, i).trim().toLowerCase(), d.slice(i + 1).trim()]]
+				})
+				frames.push({ key: (step[1] ?? "").trim(), declarations: Object.fromEntries(entries) })
+			}
+		}
+	}
+	return found ? frames : null
+}
+export function keyframes(s: PageSnapshot, name: string): readonly Frame[] | null {
+	return keyframeSteps(s, name)?.map(step => step.declarations) ?? null
+}
+export function infiniteNames(style: ComputedStyle): readonly string[] {
+	const iterations = splitTop(style["animation-iteration-count"] ?? "")
+	return splitTop(style["animation-name"] ?? "").filter((n, i) => n !== "none" && iterations[i % iterations.length] === "infinite")
+}
+export function onlyUnitPulse(frames: readonly Frame[]): boolean {
+	return (
+		frames.length > 0 &&
+		frames.every((f) =>
+			Object.entries(f).every(([p, v]) => {
+				if (p === "opacity") return true
+				if (p === "animation-timing-function") return !/linear\(|var\(/.test(v) && !overshoot(v)
+				if (p !== "scale" && p !== "transform") return false
+				if (v === "none") return true
+				const rest = p === "scale" ? v : v.replace(/scale(?:[XYZ]|3d)?\(([^)]*)\)/gi, "$1")
+				return (
+					/^[\s,0-9.+-]+$/.test(rest) &&
+					rest
+						.split(/[\s,]+/)
+						.filter(Boolean)
+						.every((n) => Number(n) >= 0 && Number(n) <= 1)
+				)
+			}),
+		)
+	)
+}
+export const overshoot = (v: string): boolean =>
+	[...v.matchAll(/cubic-bezier\(\s*([\d.+-]+)\s*,\s*([\d.+-]+)\s*,\s*([\d.+-]+)\s*,\s*([\d.+-]+)\s*\)/g)].some((m) =>
+		[Number(m[2]), Number(m[4])].some((y) => y < -0.1 || y > 1.1),
+	)
+const scalar = (v: string): number | null => (/^[-+]?(?:\d*\.)?\d+(?:px)?$/.test(v) ? Number.parseFloat(v) : null)
+const differs = (a: string | undefined, b: string | undefined): boolean => {
+	if (a === undefined || b === undefined) return false
+	const x = scalar(a),
+		y = scalar(b)
+	return x !== null && y !== null ? Math.abs(x - y) >= 4 : a.replace(/\s/g, "") !== b.replace(/\s/g, "")
+}
+function translation(f: Frame): readonly string[] | null {
+	const t = f["transform"]
+	if (t === undefined && f["translate"] === undefined) return null
+	if (t?.includes("matrix")) return []
+	const axes = ["0", "0", "0"]
+	for (const m of (t ?? "").matchAll(/translate([XYZ]|3d)?\(([^)]*)\)/gi)) {
+		const suffix = m[1]?.toLowerCase(),
+			args = (m[2] ?? "").split(/,\s*/).map((x) => x.trim())
+		if (suffix === "x" || suffix === "y" || suffix === "z") axes[suffix === "x" ? 0 : suffix === "y" ? 1 : 2] = args[0] ?? "0"
+		else
+			args.forEach((v, i) => {
+				axes[i] = v
+			})
+	}
+	if (f["translate"])
+		f["translate"].split(/\s+/).forEach((v, i) => {
+			axes[i] = v
+		})
+	return axes
+}
+export function dotPulse(frames: readonly Frame[]): boolean {
+	const declarations = frames.flatMap((f) => Object.entries(f))
+	const scales = declarations
+		.filter(([p]) => p === "transform")
+		.flatMap(([, v]) => [...v.matchAll(/scale([XY]|3d)?\(/gi)].map((m) => m[1] ?? "both"))
+	const oneAxis =
+		scales.length > 0 &&
+		new Set(scales).size === 1 &&
+		["X", "Y", "x", "y"].includes(scales[0] ?? "") &&
+		!declarations.some(([p]) => p === "scale")
+	const signal = declarations.some(
+		([p, v]) => p === "opacity" || p === "box-shadow" || p === "scale" || (p === "transform" && /scale/i.test(v) && !oneAxis),
+	)
+	if (!signal) return false
+	const translations = frames.map(translation).filter((t): t is readonly string[] => t !== null)
+	for (const a of translations)
+		for (const b of translations)
+			for (let i = 0; i < 3; i++) {
+				const x = a[i] ?? "0",
+					y = b[i] ?? "0"
+				if (!x.includes("%") && !y.includes("%") && differs(x, y)) return false
+			}
+	const sizes = frames.filter((f) => f["height"] !== undefined)
+	if (sizes.some((f) => f["height"] !== sizes[0]?.["height"]) && sizes.every((f) => f["width"] === sizes[0]?.["width"])) return false
+	const pairs = [
+		["left", "right"],
+		["top", "bottom"],
+		["inset-inline-start", "inset-inline-end"],
+		["inset-block-start", "inset-block-end"],
+		["margin-left", "margin-right"],
+		["margin-top", "margin-bottom"],
+		["margin-inline-start", "margin-inline-end"],
+		["margin-block-start", "margin-block-end"],
+	]
+	for (const a of frames)
+		for (const b of frames) {
+			if (differs(a["width"], b["width"]) || differs(a["height"], b["height"])) continue
+			for (const [x = "", y = ""] of pairs) if (differs(a[x], b[x]) !== differs(a[y], b[y])) return false
+		}
+	return true
+}
+export const toggles = (frames: readonly Frame[]): boolean =>
+	frames.some((f) => Number(f["opacity"] ?? 1) <= 0.15 || f["visibility"] === "hidden") &&
+	frames.every((f) => Object.keys(f).every((p) => ["opacity", "visibility", "animation-timing-function"].includes(p)))

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/labels.ts

@@ -0,0 +1,85 @@
+import { ancestors, childrenOf, descendants, fontSizePx, isHeading, parentOf, styleOf } from "../../../core/page"
+import { parseColor } from "../../../core/color"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+import { chroma, context, length, radii, visible } from "./appearance"
+function previous(s: PageSnapshot, e: ElementSnapshot): ElementSnapshot | null {
+	const p = parentOf(s, e)
+	if (!p) return null
+	const siblings = childrenOf(s, p),
+		at = siblings.findIndex((n) => n.index === e.index)
+	return siblings[at - 1] ?? null
+}
+export function labelBefore(s: PageSnapshot, h: ElementSnapshot): { label: ElementSnapshot; levels: number } | null {
+	let at = h
+	for (let levels = 0; levels <= 4; levels++) {
+		const label = previous(s, at)
+		if (label) return { label, levels }
+		const p = parentOf(s, at)
+		if (!p || ["body", "html"].includes(p.tag)) return null
+		at = p
+	}
+	return null
+}
+export function labelType(s: PageSnapshot, e: ElementSnapshot): ElementSnapshot {
+	let at = e
+	for (let i = 0; i < 3; i++) {
+		if (at.ownText.trim() !== "") return at
+		const children = childrenOf(s, at).filter((c) => c.text.trim() !== "")
+		const only = children[0]
+		if (children.length !== 1 || !only) return at
+		at = only
+	}
+	return at
+}
+export const application = (s: PageSnapshot, e: ElementSnapshot): boolean =>
+	context(s, e, (a) => a.tag === "dialog" || ["tabpanel", "dialog", "application"].includes(a.attributes["role"] ?? ""))
+export const caps = (e: ElementSnapshot): boolean =>
+	styleOf(e, "text-transform") === "uppercase" || (/[A-Z]/.test(e.text) && !/[a-z]/.test(e.text))
+export function heroLabel(s: PageSnapshot, h: ElementSnapshot): ElementSnapshot | null {
+	if (h.tag !== "h1" || fontSizePx(h) < 48 || application(s, h) || !visible(s, h)) return null
+	const e = previous(s, h)
+	if (!e || isHeading(e) || e.text.trim().length < 2 || e.text.trim().length > 60 || !visible(s, e)) return null
+	const ty = labelType(s, e),
+		size = fontSizePx(ty),
+		spacing = length(styleOf(ty, "letter-spacing"))
+	if (size <= 0 || size > 14) return null
+	const dated =
+		(e.tag === "time" || [...descendants(s, e)].some((c) => c.tag === "time") || /\b(?:19|20)\d{2}\b/.test(e.text)) && spacing < 1.6
+	const tracked = caps(ty) && !dated && (spacing >= 1.6 || spacing >= size * 0.08)
+	const bold = Number(styleOf(ty, "font-weight")) >= 700 && chroma(styleOf(ty, "color"), 40)
+	const dash = [e.before, e.after].some(
+		(p) =>
+			p &&
+			length(p.style["width"] ?? "") >= 8 &&
+			length(p.style["width"] ?? "") <= 80 &&
+			length(p.style["height"] ?? "") >= 1 &&
+			length(p.style["height"] ?? "") <= 6 &&
+			chroma(p.style["background-color"] ?? ""),
+	)
+	return tracked || bold || dash ? e : null
+}
+export const headingLevel = (e: ElementSnapshot): number =>
+	isHeading(e) ? Number(e.tag.slice(1)) : e.attributes["role"] === "heading" ? Number(e.attributes["aria-level"] ?? 2) : 0
+export function cardContext(s: PageSnapshot, h: ElementSnapshot, label: ElementSnapshot): boolean {
+	for (const a of ancestors(s, h)) {
+		if (a.tag === "body") break
+		if (![...descendants(s, a)].some((n) => n.index === label.index)) continue
+		if (["article", "li", "a", "button"].includes(a.tag) && a.rect.height <= s.viewport.height * 2) return true
+		if (headingLevel(h) < 3 || a.rect.height >= s.viewport.height) continue
+		const bg = parseColor(styleOf(a, "background-color")),
+			framed = radii(a).some((r) => r > 0) && bg !== null && bg.a >= 0.9
+		if (!framed) continue
+		const own = parseColor(styleOf(label, "background-color"))
+		const badge =
+			styleOf(label, "position") === "absolute" &&
+			(label.rect.y <= a.rect.y + 2 ||
+				(own !== null && own.a >= 0.9 && Math.max(Math.abs(own.r - bg.r), Math.abs(own.g - bg.g), Math.abs(own.b - bg.b)) > 3))
+		return fontSizePx(h) < 24 || badge
+	}
+	return false
+}
+export const nearAbove = (label: ElementSnapshot, h: ElementSnapshot): boolean =>
+	label.rect.y + label.rect.height <= h.rect.y + 4 &&
+	h.rect.y - label.rect.y - label.rect.height <= Math.max(64, fontSizePx(h) * 2) &&
+	label.rect.x < h.rect.x + h.rect.width &&
+	label.rect.x + label.rect.width > h.rect.x

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/raster-state.ts

@@ -0,0 +1,51 @@
+import { ancestors, childrenOf, parentOf, styleOf } from "../../../core/page"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+
+const tokens = (e: ElementSnapshot): readonly string[] => [...new Set((e.attributes["class"] ?? "").toLowerCase().split(/\s+/).filter(Boolean))]
+const opacity = (s: PageSnapshot, e: ElementSnapshot): number =>
+	[e, ...ancestors(s, e)].reduce((value, n) => {
+		const own = Number.parseFloat(styleOf(n, "opacity"))
+		return value * (Number.isFinite(own) ? own : 1)
+	}, 1)
+const transitionsOpacity = (e: ElementSnapshot): boolean => {
+	const times = styleOf(e, "transition-duration").split(",")
+	return styleOf(e, "transition-property").split(",").some((p, i) =>
+		["opacity", "all"].includes(p.trim()) && Number.parseFloat(times[i % times.length] ?? "0") > 0)
+}
+
+export function pendingRaster(s: PageSnapshot, e: ElementSnapshot): boolean {
+	if (e.motion.includes("opacity")) return true
+	const chain = [e, ...ancestors(s, e)]
+	if (chain.slice(1).some(n => Number.parseFloat(styleOf(n, "opacity")) <= 0.02) ||
+		chain.some(n => styleOf(n, "display") === "none" || styleOf(n, "visibility") === "hidden")) return true
+	const attrs = e.attributes
+	if (attrs["data-loaded"]?.trim().toLowerCase() === "false" ||
+		(attrs["data-ll-status"] !== undefined && attrs["data-ll-status"].trim().toLowerCase() !== "loaded")) return true
+	if (["data-src", "data-srcset", "data-lazy", "data-lazy-src", "data-lazy-srcset", "data-original", "data-original-src"]
+		.some(name => attrs[name] !== undefined) && (attrs["src"] ?? "").trim() === "") return true
+	const parent = parentOf(s, e)
+	const classes = [e, ...(parent ? [parent] : [])].flatMap(tokens)
+	if (classes.some(t => t.includes("lazy")) && !classes.some(t => t.includes("loaded")) &&
+		(opacity(s, e) <= 0.02 || /(?:^|;)\s*opacity\s*:/i.test(attrs["style"] ?? ""))) return true
+	if (parent && opacity(s, e) <= 0.02) {
+		const videoOver = (n: ElementSnapshot, depth: number): boolean => {
+			const w = Math.min(e.rect.x + e.rect.width, n.rect.x + n.rect.width) - Math.max(e.rect.x, n.rect.x)
+			const h = Math.min(e.rect.y + e.rect.height, n.rect.y + n.rect.height) - Math.max(e.rect.y, n.rect.y)
+			if (n.tag === "video" && opacity(s, n) > 0.02 && [n, ...ancestors(s, n)].every(a =>
+				styleOf(a, "display") !== "none" && styleOf(a, "visibility") !== "hidden") &&
+				w > 0 && h > 0 && w * h >= e.rect.width * e.rect.height * 0.5) return true
+			return depth > 0 && childrenOf(s, n).some(child => videoOver(child, depth - 1))
+		}
+		if (parent.tag === "video" || childrenOf(s, parent).some(n => n.index !== e.index && videoOver(n, 3))) return true
+	}
+	if (e.tag !== "img" || opacity(s, e) > 0.02) return false
+	const own = tokens(e)
+	const peers = s.elements.filter(other => {
+		if (other.index === e.index || other.tag !== "img" || Number.parseFloat(styleOf(other, "opacity")) < 0.5 ||
+			opacity(s, other) <= 0.02 || !transitionsOpacity(other)) return false
+		const theirs = tokens(other)
+		const shared = own.filter(t => theirs.includes(t)).length
+		return shared > 0 && own.length - shared <= 1 && theirs.filter(t => !own.includes(t)).length === 1
+	})
+	return peers.length >= 2
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/index.ts

@@ -0,0 +1,16 @@
+import type { Rule } from "../rule"
+import { COLOR_RULES } from "./color"
+import { TYPOGRAPHY_RULES } from "./typography"
+import { LAYOUT_RULES } from "./layout"
+import { DECORATION_RULES } from "./decoration"
+import { COPY_RULES } from "./copy"
+import { SOURCE_RULES } from "./source"
+
+export const ALL_RULES: readonly Rule[] = [
+	...COLOR_RULES,
+	...TYPOGRAPHY_RULES,
+	...LAYOUT_RULES,
+	...DECORATION_RULES,
+	...COPY_RULES,
+	...SOURCE_RULES,
+]

package/packages/shared-skills/skills/frontend/scripts/detect/rules/layout/body-text-viewport-edge.test.ts

@@ -0,0 +1,64 @@
+import { expect, test } from "bun:test"
+import type { NodeSpec } from "../../testing/build-snapshot"
+import { bodyTextViewportEdge } from "./body-text-viewport-edge"
+import { lines, marked } from "./support/layout-cases"
+
+const prose = "This paragraph contains substantial reading text that needs a gutter at either side of the page."
+
+test("#given full width prose with and without a gutter #then only edge touching text reports", () => {
+	expect(marked(bodyTextViewportEdge, [
+		{ id: "flush", tag: "p", text: prose, rect: { width: 1280, height: 80 }, lineRects: lines([1280, 100], 0, 0) },
+		{ id: "inset", tag: "p", text: prose, rect: { width: 1280, height: 80 }, lineRects: lines([1200], 40, 100) },
+	])).toEqual(["#flush"])
+})
+
+test("#given a phone gutter of twelve pixels #then phone and desktop floors differ", () => {
+	const node = { id: "copy", tag: "p", text: prose, rect: { x: 12, width: 296 }, lineRects: lines([296], 12, 0) }
+	expect(marked(bodyTextViewportEdge, [node], { viewport: { width: 320, height: 800 } })).toEqual([])
+	expect(marked(bodyTextViewportEdge, [{ ...node, rect: { x: 12, width: 1256 }, lineRects: lines([1256], 12, 0) }])).toEqual(["#copy"])
+})
+
+test("#given navigation and scrollable tracks beside body content #then only body content keeps the gutter requirement", () => {
+	const node = { id: "copy", tag: "p", text: prose, rect: { width: 1280 }, lineRects: lines([1280], 0, 0) }
+	expect(marked(bodyTextViewportEdge, [node])).toEqual(["#copy"])
+	expect(marked(bodyTextViewportEdge, [{ tag: "nav", children: [node] }])).toEqual([])
+	expect(marked(bodyTextViewportEdge, [{ style: { "overflow-x": "auto" }, children: [node] }])).toEqual([])
+})
+
+test("#given body text past the window #then overflow is reported once at page level", () => {
+	const node = { tag: "p", text: prose, rect: { x: 40, width: 1600 }, lineRects: lines([1600], 40, 0) }
+	expect(marked(bodyTextViewportEdge, [node, node])).toEqual(["page"])
+	expect(marked(bodyTextViewportEdge, [{ ...node, rect: { x: 1400, width: 1600 }, lineRects: lines([1600], 1400, 0) }])).toEqual([])
+})
+
+test("#given overflow on one side and a narrow gutter opposite #then both forms report", () => {
+	const node = { id: "copy", tag: "p", text: prose, rect: { x: 8, width: 1400 }, lineRects: lines([1400], 8, 0) }
+	expect(marked(bodyTextViewportEdge, [node])).toEqual(["#copy", "page"])
+})
+
+test("#given prose inside a whole card link #then its label is not body reading text", () => {
+	const node = { id: "copy", text: prose, rect: { width: 1280 }, lineRects: lines([1280], 0, 0) }
+	expect(marked(bodyTextViewportEdge, [{ tag: "a", children: [node] }])).toEqual([])
+})
+
+test("#given a genuinely running endless row #then its current text position is not a page gutter", () => {
+	const css = "@keyframes slide { from { transform: translateX(0) } to { transform: translateX(-50%) } }"
+	const track = (motion: readonly string[], state = "running", name = "slide", count = "infinite"): NodeSpec => ({
+		style: { transform: "matrix(1, 0, 0, 1, -1, 0)", "animation-name": name, "animation-iteration-count": count, "animation-play-state": state },
+		motion, rect: { x: -1, y: 0, width: 2560, height: 100 }, scroll: { scrollWidth: 2560, clientWidth: 2560 },
+		children: [
+			{ rect: { x: -1, y: 0, width: 1280, height: 100 }, children: [{ id: "copy", tag: "p", text: prose,
+				rect: { x: 8, y: 0, width: 1260, height: 48 }, lineRects: lines([1200, 800], 8, 0) }] },
+			{ rect: { x: 1279, y: 0, width: 1280, height: 100 } },
+		],
+	})
+	const host = (node: NodeSpec): NodeSpec => ({ style: { "overflow-x": "hidden" },
+		rect: { width: 1280, height: 100 }, scroll: { clientWidth: 1280 }, children: [node] })
+	expect(marked(bodyTextViewportEdge, [host(track(["transform"]))], { cssText: [css] })).toEqual([])
+	expect(marked(bodyTextViewportEdge, [host(track([], "paused"))], { cssText: [css] })).toEqual(["#copy"])
+	const scale = "@keyframes pulse { from { transform: scale(.9) } to { transform: scale(1) } }"
+	expect(marked(bodyTextViewportEdge, [host(track(["transform"], "running", "pulse"))], { cssText: [scale] })).toEqual(["#copy"])
+	const fade = "@keyframes fade { from { opacity: 0 } to { opacity: 1 } }"
+	expect(marked(bodyTextViewportEdge, [host(track(["opacity", "transform"], "running, running", "fade, slide", "infinite, 1"))],
+		{ cssText: [fade, css] })).toEqual(["#copy"])
+})

package/packages/shared-skills/skills/frontend/scripts/detect/rules/layout/body-text-viewport-edge.ts

@@ -0,0 +1,62 @@
+import { childrenOf, fontSizePx, isIgnored, shortSnippet, styleOf } from "../../core/page"
+import type { PageHit, PageRule } from "../../rule"
+import { alpha, bounds, chain, clipsX, length, outOfFlow, painted, right, scrollsX, textLines } from "./support/geometry"
+import { trackCuts } from "./support/clipping"
+import { ridesRunningTrack } from "./support/motion"
+
+export const bodyTextViewportEdge: PageRule = {
+	meta: {
+		id: "body-text-viewport-edge", name: "Body text touching viewport edge", category: "quality", severity: "warning", engine: "page",
+		description: "Reading text touches the viewport edge without a usable gutter.",
+		fixHint: "Keep at least 12px of horizontal space on phones and 16px on wider screens; constrain overflowing columns.",
+	},
+	check: ({ snapshot }) => {
+		const width = snapshot.viewport.width
+		const floor = width <= 480 ? 12 : 16
+		const hits: PageHit[] = []
+		let overflow = false
+		for (const el of snapshot.elements) {
+			if (isIgnored(snapshot, el, "body-text-viewport-edge")) continue
+			const prose = ["p", "li"].includes(el.tag)
+			const generic = ["div", "section", "article", "aside", "main"].includes(el.tag) &&
+				el.ownText !== "" && fontSizePx(el) < 28 && ["block", "flow-root"].includes(styleOf(el, "display")) &&
+				childrenOf(snapshot, el).every((c) => styleOf(c, "display") === "inline")
+			if (!(prose || generic) || el.text.length <= 40 || !painted(snapshot, el) || outOfFlow(el) ||
+				el.rect.width <= width * 0.5 || alpha(el, "background-color") > 0) continue
+			if (ridesRunningTrack(snapshot, el)) continue
+			const path = chain(snapshot, el)
+			if (generic && path.some((n) => /^(a|button|label|summary|select|textarea)$/.test(n.tag) ||
+				/^(button|link|tab|menuitem|option)$/.test(n.attributes["role"] ?? "") || n.attributes["contenteditable"] !== undefined)) continue
+			if (path.some((n) => n.tag === "nav" || n.tag === "header" && n.rect.height <= snapshot.viewport.height ||
+				scrollsX(n) || /^(pre|pre-wrap)$/.test(styleOf(n, "white-space")))) continue
+			const lines = textLines(snapshot, el)
+			const text = bounds(lines)
+			if (!text && generic) continue
+			if (text && trackCuts(snapshot, el, text)) continue
+			let left = text?.x ?? el.rect.x
+			let end = text ? right(text) : right(el.rect)
+			if (clipsX(el) && !["", "clip"].includes(styleOf(el, "text-overflow"))) {
+				left = Math.max(left, el.rect.x)
+				end = Math.min(end, right(el.rect))
+			}
+			const contentLeft = el.rect.x + length(el, "padding-left") + length(el, "border-left-width")
+			const contentEnd = right(el.rect) - length(el, "padding-right") - length(el, "border-right-width")
+			if (text && lines.length >= 2 && text.width >= (contentEnd - contentLeft) * 0.9 &&
+				!(styleOf(el, "text-align") !== "justify" && left >= 16 && end <= width - 16)) {
+				left = contentLeft
+				end = contentEnd
+			} else if (styleOf(el, "display") === "list-item") {
+				left = Math.min(left, contentLeft)
+			}
+			if (end <= 0 || left >= width) continue
+			if (path.slice(1).some((n) => styleOf(n, "position") === "fixed" && n.rect.height < snapshot.viewport.height / 2) && Math.min(left, width - end) >= 4) continue
+			if (Math.round(-left) > 0 || Math.round(end - width) > 0) overflow = true
+			if (Math.round(left) >= 0 && left < floor || Math.round(width - end) >= 0 && width - end < floor) hits.push({ element: el, message: `Body copy keeps less than ${floor}px from the viewport edge.`, snippet: shortSnippet(el) })
+		}
+		if (overflow) {
+			const widest = snapshot.elements.filter((el) => painted(snapshot, el) && !chain(snapshot, el).some(scrollsX)).sort((a, b) => right(b.rect) - right(a.rect))[0]
+			hits.push({ element: null, message: `Body text runs outside the viewport${widest ? `; widest element ${widest.selector} ends at ${right(widest.rect)}px` : ""}.`, snippet: widest ? shortSnippet(widest) : "Page overflow" })
+		}
+		return hits
+	},
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/layout/clipped-overflow-container.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from "bun:test"
+import type { NodeSpec } from "../../testing/build-snapshot"
+import { clippedOverflowContainer } from "./clipped-overflow-container"
+import { marked } from "./support/layout-cases"
+
+const popup: NodeSpec = { id: "popup", attributes: { role: "menu" }, style: { position: "absolute" }, rect: { x: 30, y: 160, width: 200, height: 80 }, text: "Menu contents" }
+const host = (child: NodeSpec, style = "hidden"): NodeSpec => ({
+	id: "host", style: { position: "relative", "overflow-x": style, "overflow-y": style }, rect: { x: 20, y: 20, width: 200, height: 120 }, children: [child],
+})
+
+test("#given escaped popup layers and decorative crops #then only popup clipping reports", () => {
+	expect(marked(clippedOverflowContainer, [host(popup)])).toEqual(["#host"])
+	expect(marked(clippedOverflowContainer, [host({ ...popup, attributes: { "aria-hidden": "true" }, text: "", id: "crop" })])).toEqual([])
+	expect(marked(clippedOverflowContainer, [host(popup, "auto")])).toEqual([])
+})
+
+test("#given nested clipping hosts #then the nearest clipping box owns the popup", () => {
+	const inner = { ...host(popup), id: "inner" }
+	expect(marked(clippedOverflowContainer, [host(inner)])).toEqual(["#inner"])
+	expect(marked(clippedOverflowContainer, [host({ ...popup, rect: { x: 30, y: 30, width: 100, height: 60 } })])).toEqual([])
+})
+
+test("#given fixed popups without and with transformed containment #then only the trapped fixed layer reports", () => {
+	const fixed = { ...popup, style: { position: "fixed" } }
+	expect(marked(clippedOverflowContainer, [host(fixed)])).toEqual([])
+	const transformed = { ...host(fixed), style: { position: "relative", transform: "matrix(1, 0, 0, 1, 0, 0)", "overflow-x": "hidden", "overflow-y": "hidden" } }
+	expect(marked(clippedOverflowContainer, [transformed])).toEqual(["#host"])
+})
+
+test("#given class named dropdowns and camel case slider tracks #then neither is an escaping popup", () => {
+	expect(marked(clippedOverflowContainer, [host({ ...popup, attributes: { class: "dropdown-panel" } })])).toEqual([])
+	expect(marked(clippedOverflowContainer, [{ ...host(popup), attributes: { class: "slickViewport" } }])).toEqual([])
+	expect(marked(clippedOverflowContainer, [host({ ...popup, attributes: { role: "menu", "aria-hidden": "true" } })])).toEqual([])
+})
+
+test("#given modal and nonmodal open dialogs #then only the nonmodal dialog can be trapped by a clip", () => {
+	const dialog = { ...popup, tag: "dialog", attributes: { open: "" }, modal: true }
+	expect(marked(clippedOverflowContainer, [host(dialog)])).toEqual([])
+	expect(marked(clippedOverflowContainer, [host({ ...dialog, modal: false })])).toEqual(["#host"])
+})

package/packages/shared-skills/skills/frontend/scripts/detect/rules/layout/clipped-overflow-container.ts

@@ -0,0 +1,15 @@
+import { shortSnippet } from "../../core/page"
+import type { PageRule } from "../../rule"
+import { clippedChild } from "./support/clipping"
+
+export const clippedOverflowContainer: PageRule = {
+	meta: {
+		id: "clipped-overflow-container", name: "Positioned child clipped by overflow container", category: "quality", severity: "advisory", engine: "page",
+		description: "A container cuts off a positioned menu, tooltip, or dialog that needs to escape it.",
+		fixHint: "Render the popup outside the clipping box or remove the clip from its containing block.",
+	},
+	check: ({ snapshot }) => snapshot.elements.flatMap((el) => {
+		const child = clippedChild(snapshot, el)
+		return child ? [{ element: el, message: `${el.selector} clips positioned popup ${child.selector}.`, snippet: shortSnippet(el) }] : []
+	}),
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/layout/content-hidden-at-rest.test.ts

@@ -0,0 +1,62 @@
+import { expect, test } from "bun:test"
+import { contentHiddenAtRest } from "./content-hidden-at-rest"
+import { marked } from "./support/layout-cases"
+
+const hidden = { id: "reveal", style: { opacity: "0" }, text: "Invisible main content. ".repeat(10) }
+const visible = { tag: "p", text: "Visible copy. ".repeat(10) }
+
+test("#given a failed reveal and visible content #then the page fails the hidden share threshold", () => {
+	expect(marked(contentHiddenAtRest, [hidden, visible])).toEqual(["page"])
+	expect(marked(contentHiddenAtRest, [{ ...hidden, style: { opacity: "1" } }, visible])).toEqual([])
+})
+
+test("#given closed dialogs menus and panels #then their text is excluded from the hidden share", () => {
+	expect(marked(contentHiddenAtRest, [hidden, visible])).toEqual(["page"])
+	for (const role of ["dialog", "tabpanel", "menu"]) {
+		expect(marked(contentHiddenAtRest, [{ ...hidden, attributes: { role } }, visible])).toEqual([])
+	}
+	expect(marked(contentHiddenAtRest, [{ tag: "nav", children: [hidden] }, visible])).toEqual([])
+})
+
+test("#given a selected tab panel whose reveal failed #then it counts as expected content", () => {
+	const panel = { ...hidden, attributes: { role: "tabpanel" } }
+	expect(marked(contentHiddenAtRest, [{ tag: "button", attributes: { "aria-controls": "reveal", "aria-selected": "true" } }, panel, visible])).toEqual(["page"])
+	expect(marked(contentHiddenAtRest, [{ tag: "button", attributes: { "aria-controls": "reveal", "aria-selected": "false" } }, panel, visible])).toEqual([])
+})
+
+test("#given the character and share boundaries #then only substantial hidden content fails", () => {
+	expect(marked(contentHiddenAtRest, [{ ...hidden, text: "x".repeat(150) }, { text: "v".repeat(50) }])).toEqual(["page"])
+	expect(marked(contentHiddenAtRest, [{ ...hidden, text: "x".repeat(149) }, { text: "v".repeat(51) }])).toEqual([])
+	expect(marked(contentHiddenAtRest, [{ ...hidden, text: "x".repeat(150) }, { text: "v".repeat(350) }])).toEqual([])
+})
+
+test("#given a hidden viewport overlay and a fixed app shell #then only the app shell is page content", () => {
+	const layer = { ...hidden, style: { position: "fixed", visibility: "hidden" }, rect: { x: 0, y: 0, width: 1280, height: 800 } }
+	const page = { ...visible, text: "Visible copy. ".repeat(60) }
+	expect(marked(contentHiddenAtRest, [layer, page])).toEqual([])
+	expect(marked(contentHiddenAtRest, [{ ...layer, text: "Hidden application text. ".repeat(40), children: [{ tag: "main" }] }, page])).toEqual(["page"])
+})
+
+test("#given sliders with no visible slide and with a visible current slide #then only waiting slides of the started slider count", () => {
+	const slide = { ...hidden, tag: "p" }
+	const slider = { attributes: { class: "swiper" }, children: [slide] }
+	expect(marked(contentHiddenAtRest, [slider, visible])).toEqual([])
+	expect(marked(contentHiddenAtRest, [{ ...slider, children: [slide, { tag: "p", text: "Current offer" }] }, visible])).toEqual(["page"])
+})
+
+test("#given an aria labelled selected tab #then a failed reveal remains hidden content", () => {
+	const tab = { id: "tab", tag: "button", attributes: { "aria-selected": "true" } }
+	const panel = { ...hidden, attributes: { role: "tabpanel", "aria-labelledby": "tab" } }
+	expect(marked(contentHiddenAtRest, [tab, panel, visible])).toEqual(["page"])
+})
+
+test("#given a long overlay on a larger page #then capped snippets do not decide its share", () => {
+	const layer = { text: "Hidden menu text. ".repeat(70), style: { position: "fixed", visibility: "hidden" },
+		rect: { x: 0, y: 0, width: 1280, height: 800 } }
+	expect(marked(contentHiddenAtRest, [layer, { text: "Visible page text. ".repeat(170) }])).toEqual([])
+})
+
+test("#given unrelated tab and content class tokens #then they do not name a closed tab panel", () => {
+	expect(marked(contentHiddenAtRest, [{ ...hidden, attributes: { class: "tab content" } }, visible])).toEqual(["page"])
+	expect(marked(contentHiddenAtRest, [{ ...hidden, attributes: { class: "tab-content" } }, visible])).toEqual([])
+})

package/packages/shared-skills/skills/frontend/scripts/detect/rules/layout/content-hidden-at-rest.ts

@@ -0,0 +1,63 @@
+import { childrenOf, descendants, styleOf } from "../../core/page"
+import type { PageRule } from "../../rule"
+import type { ElementSnapshot, PageSnapshot } from "../../types"
+import { bottom, chain, hasRole, right } from "./support/geometry"
+import { classWords, closedClass, unstartedSlider } from "./support/hidden-interface"
+
+function closed(s: PageSnapshot, el: ElementSnapshot): boolean {
+	const controls = s.elements.filter((n) => (n.attributes["aria-controls"] ?? "").split(/\s+/).includes(el.attributes["id"] ?? "\u0000"))
+	const labels = (el.attributes["aria-labelledby"] ?? "").split(/\s+/)
+	const selected = (hasRole(el, ["tabpanel"]) || classWords(el).some((word) => ["tab", "tabs", "tabpanel", "tabpane"].includes(word))) &&
+		(controls.some((n) => n.attributes["aria-selected"] === "true" || n.attributes["aria-expanded"] === "true") ||
+		s.elements.some((n) => labels.includes(n.attributes["id"] ?? "\u0000") && n.attributes["aria-selected"] === "true"))
+	if (!selected && controls.some((n) => n.attributes["aria-selected"] === "false" || n.attributes["aria-expanded"] === "false")) return true
+	if (!selected && (hasRole(el, ["dialog", "alertdialog", "tabpanel"]) || closedClass(el))) return true
+	if (styleOf(el, "position") === "fixed" && (right(el.rect) <= 0 || el.rect.x >= s.viewport.width)) return true
+	const path = chain(s, el)
+	if (path.some((n) => n.attributes["inert"] !== undefined || n.tag === "nav" || hasRole(n, ["navigation", "menu", "menubar"]))) return true
+	if (styleOf(el, "position") === "fixed" && /^(hidden|collapse)$/.test(styleOf(el, "visibility")) &&
+		el.rect.x <= 1 && el.rect.y <= 1 && right(el.rect) >= s.viewport.width - 1 && bottom(el.rect) >= s.viewport.height - 1) {
+		const nodes = [el, ...descendants(s, el)]
+		const chars = nodes.reduce((sum, n) => sum + n.ownText.length, 0)
+		const pageChars = s.elements.reduce((sum, n) => sum + n.ownText.length, 0)
+		if (chars * 2 < pageChars && !nodes.some((n) => n.tag === "main" || n.tag === "h1" || hasRole(n, ["main"]))) return true
+	}
+	if (path.some((n) => /^(absolute|fixed)$/.test(styleOf(n, "position")) &&
+		!["", "none", "matrix(1, 0, 0, 1, 0, 0)"].includes(styleOf(n, "transform")) &&
+		/\b(?:transform|all)\b/.test(styleOf(n, "transition-property")) &&
+		(right(n.rect) <= 0 || n.rect.x >= s.viewport.width))) return true
+	const p = el.parent === null ? undefined : s.elements[el.parent]
+	const siblings = p ? childrenOf(s, p) : []
+	const previous = siblings[siblings.indexOf(el) - 1]
+	if (previous && (previous.attributes["aria-expanded"] === "false" ||
+		childrenOf(s, previous).length === 1 && childrenOf(s, previous)[0]?.attributes["aria-expanded"] === "false")) return true
+	return path.slice(1).some((n) => {
+		const triggers = s.elements.filter((t) => (t.attributes["aria-controls"] ?? "").split(/\s+/).includes(n.attributes["id"] ?? "\u0000"))
+		return triggers.some((t) => t.attributes["aria-expanded"] === "false" || t.attributes["aria-selected"] === "false") &&
+			!triggers.some((t) => t.attributes["aria-expanded"] === "true" || t.attributes["aria-selected"] === "true")
+	})
+}
+
+export const contentHiddenAtRest: PageRule = {
+	meta: {
+		id: "content-hidden-at-rest", name: "Content invisible at rest", category: "quality", severity: "error", engine: "page",
+		description: "A large share of page text remains transparent or hidden instead of appearing as content.",
+		fixHint: "Show content by default and enhance its entrance without making visibility depend on a reveal script.",
+	},
+	check: ({ snapshot }) => {
+		let total = 0
+		let hidden = 0
+		for (const el of snapshot.elements) {
+			if (el.ownText === "") continue
+			const path = chain(snapshot, el)
+			if (path.some((n) => /^(script|style|noscript|template|title|head|meta|link|option|optgroup|select|datalist|dialog)$/.test(n.tag) ||
+				n.attributes["hidden"] !== undefined || n.attributes["aria-hidden"] === "true" || styleOf(n, "display") === "none")) continue
+			const invisible = [...path].reverse().find((n) => Number.parseFloat(styleOf(n, "opacity")) <= 0.02 || /^(hidden|collapse)$/.test(styleOf(n, "visibility")))
+			if (invisible && (closed(snapshot, invisible) || unstartedSlider(snapshot, invisible))) continue
+			total += el.ownText.length
+			if (invisible) hidden += el.ownText.length
+		}
+		if (total < 200 || hidden < 150 || hidden / total <= 0.3) return []
+		return [{ element: null, message: `${hidden} of ${total} characters (${Math.round(hidden / total * 100)}%) remain hidden.`, snippet: `${hidden}/${total} hidden characters` }]
+	},
+}