oh-my-opencode 5.1.51 → 5.1.54

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/marquee.ts

@@ -0,0 +1,51 @@
+import type { PageRule } from "../../rule"
+import { ancestors, descendants, shortSnippet, styleOf } from "../../core/page"
+import { visible } from "./support/appearance"
+import { infiniteNames, keyframes } from "./support/keyframes"
+import { pageIgnored } from "../color/support/page-ignore"
+import type { PageSnapshot } from "../../types"
+
+function marqueeKeyframes(snapshot: PageSnapshot, name: string): boolean {
+	const frames = keyframes(snapshot, name)
+	if (frames === null) return /marquee|ticker|crawl|scroll/i.test(name)
+	const percentages = frames.flatMap((frame) => [...(frame["transform"] ?? "").matchAll(/\btranslate(?:x|3d)?\(\s*(?:calc\(\s*)?(-?[\d.]+)%/gi)]
+		.map((match) => Number(match[1])))
+	if (percentages.length === 0 || (percentages.length === 1 && frames.some((frame) =>
+		frame["opacity"] !== undefined || /\bscale\(/i.test(frame["transform"] ?? "")))) return false
+	const travel = percentages.length === 1 ? Math.abs(percentages[0] ?? 0) : Math.max(...percentages) - Math.min(...percentages)
+	return travel >= 20
+}
+export const marquee: PageRule = {
+	meta: {
+		id: "marquee",
+		name: "Auto-scrolling marquee",
+		category: "slop",
+		severity: "warning",
+		engine: "page",
+		description: "Content crawls automatically through a repeating horizontal loop.",
+		fixHint: "Keep the content still and let readers scroll it themselves.",
+	},
+	check: ({ snapshot }) => {
+		const seen = new Set<number>()
+		const strips = new Set<number>()
+		return snapshot.elements.flatMap((e) => {
+			if (!visible(snapshot, e) || pageIgnored(snapshot, e, "marquee") || [...ancestors(snapshot, e)].some((a) => seen.has(a.index))) return []
+			const carries =
+				e.text.trim() !== "" ||
+				[...descendants(snapshot, e)].some(
+					(c) =>
+						["img", "picture", "video", "canvas", "iframe", "object", "embed", "marquee"].includes(c.tag) ||
+						(c.tag === "svg" && c.attributes["aria-hidden"] !== "true"),
+				)
+			const loop = (style: Readonly<Record<string, string>>): boolean =>
+				infiniteNames(style).some((name) => marqueeKeyframes(snapshot, name))
+			const pseudo = [e.before, e.after].some((p) => p && loop(p.style) && !["", '""', "none", "normal"].includes(p.style["content"] ?? ""))
+			if (e.tag !== "marquee" && !(carries && loop(e.style)) && !pseudo) return []
+			const strip = [...ancestors(snapshot, e)].find((a) => ["hidden", "clip", "scroll", "auto"].includes(styleOf(a, "overflow-x")))
+			if (strip && strips.has(strip.index)) return []
+			if (strip) strips.add(strip.index)
+			seen.add(e.index)
+			return [{ element: e, message: "Continuously scrolling content track", snippet: shortSnippet(e) }]
+		})
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/organic-clip-path.ts

@@ -0,0 +1,41 @@
+import type { PageRule } from "../../rule"
+import { shortSnippet, styleOf } from "../../core/page"
+import { visible, splitTop } from "./support/appearance"
+import { geometricPolygon, roundedPath } from "./support/clip-geometry"
+import { cssCandidates, matchesSelector } from "./support/css-candidates"
+export const organicClipPath: PageRule = {
+	meta: {
+		id: "organic-clip-path",
+		name: "Organic contour drawn as clip-path",
+		category: "quality",
+		severity: "warning",
+		engine: "page",
+		description: "A complex CSS contour substitutes for produced organic material.",
+		fixHint: "Use an image-derived alpha matte; keep CSS clipping for simple geometry.",
+	},
+	check: ({ snapshot }) => {
+		const seen = new Set<string>()
+		const declarations = [...cssCandidates(snapshot)].filter(([, style]) => style["clip-path"] !== undefined)
+		return snapshot.elements.flatMap((e) => {
+			if (!visible(snapshot, e)) return []
+			const clip = styleOf(e, "clip-path"),
+				kind = /^(polygon|path)\(([\s\S]*)\)$/.exec(clip),
+				body = kind?.[2]
+			if (!kind || body === undefined) return []
+			const points = splitTop(body)
+			const offGrid = [...body.matchAll(/[-+]?(?:\d*\.)?\d+/g)].filter(
+				(m) => Math.abs(Number(m[0]) - Math.round(Number(m[0]) / 25) * 25) > 0.5,
+			).length
+			const organic =
+				kind[1] === "path"
+					? (body.match(/[CSQTA]/gi)?.length ?? 0) >= 3 && !roundedPath(body)
+					: points.length >= 10 && offGrid >= points.length && !geometricPolygon(body)
+			const inline = /(?:^|;)\s*clip-path\s*:/i.test(e.attributes["style"] ?? "")
+			const selector = declarations.find(([selector]) => matchesSelector(snapshot, e, selector))?.[0]
+			const key = inline ? clip : (selector ?? e.selector) + clip
+			if (!organic || seen.has(key)) return []
+			seen.add(key)
+			return [{ element: e, message: "Organic contour approximated with CSS " + kind[1], snippet: shortSnippet(e) }]
+		})
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/pulsing-dot.ts

@@ -0,0 +1,72 @@
+import type { PageHit, PageRule } from "../../rule"
+import type { ComputedStyle, ElementSnapshot, PageSnapshot } from "../../types"
+import { ancestors, shortSnippet, styleOf } from "../../core/page"
+import { radii, splitTop } from "./support/appearance"
+import { cssCandidates, matchesSelector } from "./support/css-candidates"
+import { dotPulse, infiniteNames, keyframes } from "./support/keyframes"
+
+function pulses(s: PageSnapshot, style: ComputedStyle): boolean {
+	const shorthand = splitTop(style["animation"] ?? "").filter(v => /\binfinite\b/.test(v))
+	const names = [...infiniteNames(style), ...shorthand.flatMap(v => v.split(/\s+/).filter(n => keyframes(s, n) !== null || /pulse|ping|ripple|beacon/i.test(n)))]
+	return names.some(n => {
+		const frames = keyframes(s, n)
+		return frames === null ? /pulse|ping|ripple|beacon/i.test(n) : dotPulse(frames)
+	})
+}
+const shown = (s: PageSnapshot, e: ElementSnapshot): boolean =>
+	[e, ...ancestors(s, e)].every(n => styleOf(n, "display") !== "none" && styleOf(n, "visibility") !== "hidden" &&
+		Number.parseFloat(styleOf(n, "opacity")) !== 0 && n.attributes["hidden"] === undefined)
+const dotSize = (w: number, h: number): boolean =>
+	w >= 2 && h >= 2 && w <= 16 && h <= 16 && Math.max(w, h) <= 1.5 * Math.min(w, h)
+
+export const pulsingDot: PageRule = {
+	meta: {
+		id: "pulsing-dot", name: "Pulsing status dot", category: "slop", severity: "warning", engine: "page",
+		description: "A tiny circular indicator pulses continuously.",
+		fixHint: "Keep the indicator static unless it represents live changing data.",
+	},
+	check: ({ snapshot }) => {
+		const hits: PageHit[] = []
+		const covered = new Set<number>()
+		const candidates = cssCandidates(snapshot)
+		const vars = new Map([...candidates.values()].flatMap(d => Object.entries(d).filter(([p]) => p.startsWith("--"))))
+		const length = (value: string): number => {
+			const resolved = value.replace(/var\((--[\w-]+)\)/g, (_, name: string) => vars.get(name) ?? "")
+			const m = /^([\d.]+)(px|rem|em)?$/.exec(resolved)
+			return m ? Number(m[1]) * (m[2] === "rem" || m[2] === "em" ? 16 : 1) : Number.NaN
+		}
+		for (const [selector, style] of candidates) {
+			const w = length(style["width"] ?? style["inline-size"] ?? ""), h = length(style["height"] ?? style["block-size"] ?? "")
+			const radius = style["border-radius"] ?? ""
+			if (!dotSize(w, h) || !pulses(snapshot, style) ||
+				!radius.split(/[\s/]+/).every(r => r.endsWith("%") ? Number.parseFloat(r) >= 40 : length(r) >= Math.min(w, h) * 0.4)) continue
+			const matches = snapshot.elements.filter(e => matchesSelector(snapshot, e, selector) && shown(snapshot, e))
+			const first = matches[0]
+			if (!first) continue
+			matches.forEach(e => covered.add(e.index))
+			hits.push({ element: first, message: "Infinitely pulsing " + w + "x" + h + "px status dot", snippet: shortSnippet(first) })
+		}
+		const tailwind = new Set<string>()
+		for (const e of snapshot.elements) {
+			const classes = e.attributes["class"] ?? ""
+			if (/(?:^|\s)animate-(?:ping|pulse)(?:$|\s)/.test(classes) && /(?:^|\s)rounded-full(?:$|\s)/.test(classes) &&
+				/(?:^|\s)[wh]-(?:0\.5|1|1\.5|2|2\.5|3|3\.5|4)(?:$|\s)/.test(classes)) {
+				const side = (name: string): number | undefined => {
+					const value = new RegExp("(?:^|\\s)" + name + "-([\\d.]+)(?:$|\\s)").exec(classes)?.[1]
+					return value === undefined ? undefined : Number(value) * 4
+				}
+				const w = side("w"), h = side("h")
+				if ((w === undefined || h === undefined || dotSize(w, h)) && !tailwind.has(classes)) {
+					tailwind.add(classes)
+					covered.add(e.index)
+					hits.push({ element: e, message: "Infinitely pulsing utility status dot", snippet: shortSnippet(e) })
+				}
+			}
+			if (covered.has(e.index) || !shown(snapshot, e) || !pulses(snapshot, e.style)) continue
+			const w = e.rect.width, h = e.rect.height
+			if (dotSize(w, h) && radii(e).every(r => r >= Math.min(w, h) * 0.4))
+				hits.push({ element: e, message: "Infinitely pulsing " + w + "x" + h + "px status dot", snippet: shortSnippet(e) })
+		}
+		return hits
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/repeating-stripes-gradient.ts

@@ -0,0 +1,25 @@
+import type { PageRule } from "../../rule"
+import { shortSnippet } from "../../core/page"
+import { visible } from "./support/appearance"
+import { repeats } from "./support/gradient-pattern"
+export const repeatingStripesGradient: PageRule = {
+	meta: {
+		id: "repeating-stripes-gradient",
+		name: "Repeating-gradient stripes",
+		category: "slop",
+		severity: "advisory",
+		engine: "page",
+		description: "Repeating gradient bands decorate a surface without adding structure.",
+		fixHint: "Use a deliberate texture or keep the surface plain.",
+	},
+	check: ({ snapshot }) => {
+		const e = snapshot.elements.find(
+			(e) =>
+				visible(snapshot, e) &&
+				[e.style, e.before?.style, e.after?.style].some((s) =>
+					["background-image", "mask-image", "-webkit-mask-image"].some((p) => repeats(s?.[p] ?? "")),
+				),
+		)
+		return e ? [{ element: e, message: "Repeating gradient surface stripes", snippet: shortSnippet(e) }] : []
+	},
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/shape-assembled-illustration.ts

@@ -0,0 +1,58 @@
+import type { PageRule } from "../../rule"
+import { ancestors, descendants, shortSnippet } from "../../core/page"
+import { visible } from "./support/appearance"
+export const shapeAssembledIllustration: PageRule = {
+	meta: {
+		id: "shape-assembled-illustration",
+		name: "Shape-assembled illustration",
+		category: "slop",
+		severity: "advisory",
+		engine: "page",
+		description: "A hero-sized SVG scene is assembled mainly from primitive shapes.",
+		fixHint: "Use produced artwork, a photograph, or a deliberately drawn illustration.",
+	},
+	check: ({ snapshot }) =>
+		snapshot.elements.flatMap((e) => {
+			if (e.tag !== "svg" || !visible(snapshot, e) || e.rect.width < 200 || e.rect.height < 200) return []
+			const all = [...descendants(snapshot, e)]
+			if (all.filter((n) => n.tag === "text").length > 2 || all.some((n) => n.tag === "pattern")) return []
+			const primitive = (tag: string): boolean => ["rect", "circle", "ellipse", "polygon"].includes(tag)
+			const drawn = (tag: string): boolean => primitive(tag) || ["path", "line", "polyline"].includes(tag)
+			const painted = all.filter((n) => ![...ancestors(snapshot, n)].some((a) => a.tag === "defs"))
+			const used = painted
+				.filter((n) => n.tag === "use")
+				.flatMap((n) => {
+					const id = (n.attributes["href"] ?? n.attributes["xlink:href"] ?? "").replace(/^#/, "")
+					const target = all.find((a) => a.attributes["id"] === id && drawn(a.tag))
+					return target ? [target] : []
+				})
+			const shapes = [...painted, ...used],
+				primitives = shapes.filter((n) => primitive(n.tag))
+			if (primitives.length < 8 || primitives.length < shapes.filter((n) => drawn(n.tag)).length * 0.5) return []
+			const fills = new Set(
+				[e, ...all]
+					.map((n) => n.attributes["fill"]?.toLowerCase())
+					.filter((v) => v !== undefined && !["none", "transparent", "currentcolor", "inherit", ""].includes(v)),
+			)
+			if (fills.size < 3) return []
+			const rects = primitives
+				.filter((n) => n.tag === "rect")
+				.map((n) => ({ w: Number(n.attributes["width"]), h: Number(n.attributes["height"]) }))
+				.filter((r) => Number.isFinite(r.w) && Number.isFinite(r.h))
+			if (
+				primitives.length <= 400 &&
+				primitives.filter((n) => ["circle", "ellipse", "polygon"].includes(n.tag)).length < primitives.length * 0.25
+			) {
+				const series = rects.some((a) => {
+					const sameWidth = rects.filter((b) => Math.abs(a.w - b.w) <= 1),
+						sameHeight = rects.filter((b) => Math.abs(a.h - b.h) <= 1)
+					return (
+						(sameWidth.length >= primitives.length / 2 && sameWidth.some((b) => Math.abs(b.h - a.h) > 1)) ||
+						(sameHeight.length >= primitives.length / 2 && sameHeight.some((b) => Math.abs(b.w - a.w) > 1))
+					)
+				})
+				if (series) return []
+			}
+			return [{ element: e, message: "Large SVG scene assembled from " + primitives.length + " primitives", snippet: shortSnippet(e) }]
+		}),
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/side-tab.ts

@@ -0,0 +1,17 @@
+import type { PageRule } from "../../rule"
+import { borderHits, childStripeHit, stripeHit } from "./support/borders"
+import { pageIgnored } from "../color/support/page-ignore"
+export const sideTab: PageRule = {
+	meta: {
+		id: "side-tab",
+		name: "Side-tab accent border",
+		category: "slop",
+		severity: "warning",
+		engine: "page",
+		description: "A colored edge turns a card into a decorative side tab.",
+		fixHint: "Remove the stripe and use spacing or a restrained surface change.",
+	},
+	check: ({ snapshot }) =>
+		snapshot.elements.flatMap((e) => pageIgnored(snapshot, e, "side-tab") ? []
+			: [...borderHits(snapshot, e, "side-tab"), ...stripeHit(snapshot, e), ...childStripeHit(snapshot, e)]),
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/support/appearance.ts

@@ -0,0 +1,110 @@
+import { ancestors, isRendered, px, styleOf } from "../../../core/page"
+import { blend, parseColor, type Rgba } from "../../../core/color"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+
+export const sides = ["top", "right", "bottom", "left"] as const
+export const corners = ["top-left", "top-right", "bottom-right", "bottom-left"] as const
+export const borderSafe = new Set([
+	"blockquote",
+	"nav",
+	"a",
+	"input",
+	"textarea",
+	"select",
+	"pre",
+	"code",
+	"span",
+	"th",
+	"td",
+	"tr",
+	"li",
+	"button",
+	"hr",
+	"html",
+	"head",
+	"body",
+	"script",
+	"style",
+	"link",
+	"meta",
+	"title",
+	"br",
+	"img",
+	"svg",
+	"path",
+	"circle",
+	"rect",
+	"line",
+	"polyline",
+	"polygon",
+	"g",
+	"defs",
+	"use",
+])
+export const length = (value: string): number => px(value) ?? (value.trim() === "0" ? 0 : Number.NaN)
+export const chroma = (value: string, floor = 30): boolean => {
+	const c = parseColor(value)
+	return c !== null && c.a >= 0.1 && Math.max(c.r, c.g, c.b) - Math.min(c.r, c.g, c.b) >= floor
+}
+export function borderAccent(value: string): boolean {
+	const fn = /^(oklch|oklab|lch|lab|hsl|hsla|hwb)\(([^)]*)\)$/i.exec(value)
+	if (!fn) return chroma(value)
+	const parts = (fn[2] ?? "").split("/")[0]?.replace(/,/g, " ").trim().split(/\s+/) ?? []
+	const n = (i: number, full: number): number => Number.parseFloat(parts[i] ?? "0") * ((parts[i] ?? "").endsWith("%") ? full / 100 : 1)
+	const name = fn[1]?.toLowerCase()
+	if (name === "oklch") return n(1, 0.4) >= 0.02
+	if (name === "lch") return n(1, 150) >= 3
+	if (name === "oklab") return Math.hypot(n(1, 0.4), n(2, 0.4)) >= 0.02
+	if (name === "lab") return Math.hypot(n(1, 125), n(2, 125)) >= 3
+	if (name === "hwb") return 1 - Math.min(100, n(1, 100) + n(2, 100)) / 100 >= 0.1
+	return n(1, 100) >= 10
+}
+const radius = (el: ElementSnapshot, corner: string): number => {
+	const parts = styleOf(el, "border-" + corner + "-radius").split(/\s+/)
+	const values = parts.map((v) => (v.endsWith("%") ? (Number.parseFloat(v) * Math.min(el.rect.width, el.rect.height)) / 100 : length(v)))
+	return Math.min(...values)
+}
+export const radii = (el: ElementSnapshot): readonly number[] => corners.map((c) => radius(el, c))
+export const roundedAway = (el: ElementSnapshot, side: number): boolean => {
+	const far =
+		[
+			[2, 3],
+			[0, 3],
+			[0, 1],
+			[1, 2],
+		][side] ?? []
+	const values = radii(el)
+	return far.every((i) => (values[i] ?? 0) >= 4)
+}
+export const visible = (s: PageSnapshot, e: ElementSnapshot): boolean =>
+	isRendered(s, e) &&
+	[e, ...ancestors(s, e)].every(
+		(a) => styleOf(a, "display") !== "none" && styleOf(a, "visibility") !== "hidden" && a.attributes["hidden"] === undefined,
+	)
+export const context = (s: PageSnapshot, e: ElementSnapshot, predicate: (e: ElementSnapshot) => boolean): boolean =>
+	[e, ...ancestors(s, e)].some(predicate)
+export const selected = (e: ElementSnapshot): boolean =>
+	e.attributes["aria-selected"] === "true" ||
+	(e.attributes["aria-current"] !== undefined && e.attributes["aria-current"] !== "false") ||
+	/^(selected|active|checked|current)$/i.test(e.attributes["data-state"] ?? e.attributes["data-status"] ?? "") ||
+	/(?:^|[\s_-])(?:selected|current|checked|active)(?:$|[\s_-])/.test(e.attributes["class"] ?? "")
+export const showsOver = (paint: Rgba, surface: Rgba): boolean => {
+	const over = blend(paint, surface)
+	return Math.max(Math.abs(over.r - surface.r), Math.abs(over.g - surface.g), Math.abs(over.b - surface.b)) >= 8
+}
+export function splitTop(value: string, separator: RegExp = /,/): string[] {
+	let depth = 0,
+		start = 0
+	const parts: string[] = []
+	for (let i = 0; i < value.length; i++) {
+		const c = value[i] ?? ""
+		if (c === "(") depth++
+		else if (c === ")") depth--
+		else if (depth === 0 && separator.test(c)) {
+			parts.push(value.slice(start, i).trim())
+			start = i + 1
+		}
+	}
+	parts.push(value.slice(start).trim())
+	return parts.filter(Boolean)
+}

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/support/assert-cases.ts

@@ -0,0 +1,25 @@
+import { expect } from "bun:test"
+import type { PageRule } from "../../../rule"
+import type { DetectConfig } from "../../../types"
+import { buildSnapshot, type NodeSpec } from "../../../testing/build-snapshot"
+import { lintSnapshot } from "../../../lint"
+export function assertCases(
+	rule: PageRule,
+	nodes: readonly NodeSpec[],
+	expected: readonly string[],
+	options: { readonly cssText?: readonly string[]; readonly config?: DetectConfig } = {},
+): void {
+	const snapshot = buildSnapshot(nodes, { cssText: options.cssText ?? [] })
+	const findings = lintSnapshot(snapshot, { rules: [rule], config: options.config ?? {} })
+	expect(findings.map((f) => (f.location.kind === "element" ? f.location.selector : "page"))).toEqual([...expected])
+}
+export const round = (radius: string): Readonly<Record<string, string>> =>
+	Object.fromEntries(["top-left", "top-right", "bottom-right", "bottom-left"].map((c) => ["border-" + c + "-radius", radius]))
+export const border = (width: string, color = "rgb(230, 231, 233)"): Readonly<Record<string, string>> =>
+	Object.fromEntries(
+		["top", "right", "bottom", "left"].flatMap((s) => [
+			["border-" + s + "-width", width],
+			["border-" + s + "-style", "solid"],
+			["border-" + s + "-color", color],
+		]),
+	)

package/packages/omo-codex/plugin/skills/frontend/scripts/detect/rules/decoration/support/borders.ts

@@ -0,0 +1,150 @@
+import { ancestors, parentOf, shortSnippet, styleOf } from "../../../core/page"
+import { parseColor } from "../../../core/color"
+import { parseShadow } from "../../../core/shadow"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+import type { PageHit } from "../../../rule"
+import { borderAccent, borderSafe, chroma, context, length, radii, roundedAway, selected, sides, visible } from "./appearance"
+
+export function borderHits(s: PageSnapshot, e: ElementSnapshot, rule: string): PageHit[] {
+	if (
+		!visible(s, e) ||
+		borderSafe.has(e.tag) ||
+		e.rect.width < 20 ||
+		e.rect.height < 20 ||
+		context(
+			s,
+			e,
+			(a) =>
+				["status", "alert", "alertdialog", "log"].includes(a.attributes["role"] ?? "") ||
+				["polite", "assertive"].includes(a.attributes["aria-live"] ?? ""),
+		)
+	)
+		return []
+	const rs = radii(e),
+		min = Math.min(e.rect.width, e.rect.height)
+	if (Math.max(e.rect.width, e.rect.height) <= min * 1.1 && rs.every((r) => r >= min / 2 - 0.5)) return []
+	const widths = sides.map((side) => length(styleOf(e, "border-" + side + "-width")))
+	return sides.flatMap((side, i) => {
+		const w = widths[i] ?? 0,
+			other = Math.max(...widths.filter((_, j) => i !== j))
+		if (w < 2 || !(other <= 1 || w >= other * 2) || !borderAccent(styleOf(e, "border-" + side + "-color"))) return []
+		const lateral = i === 1 || i === 3
+		const id = lateral ? "side-tab" : (rs[0] ?? 0) > 0 ? "border-accent-on-rounded" : "side-tab"
+		if (
+			id !== rule ||
+			(lateral && !roundedAway(e, i)) ||
+			(!lateral && (rs[0] ?? 0) === 0 && (w < 3 || w > 12 || !roundedAway(e, i) || context(s, e, selected)))
+		)
+			return []
+		return [{ element: e, message: "Accent border on the " + side + " edge (" + w + "px)", snippet: shortSnippet(e) }]
+	})
+}
+
+export function stripeHit(s: PageSnapshot, e: ElementSnapshot): PageHit[] {
+	if (!visible(s, e) || e.rect.width <= 40 || e.rect.height < 16) return []
+	const hosts = [e, ...ancestors(s, e)]
+	if (hosts.some((a) => ["nav", "blockquote", "pre"].includes(a.tag))) return []
+	const rowNode = (a: ElementSnapshot): boolean =>
+		["tr", "td", "th"].includes(a.tag) ||
+		["row", "cell", "gridcell", "rowheader"].includes(a.attributes["role"] ?? "") ||
+		/(?:^|[\s_-])(?:row|cell)(?:$|[\s_-])/.test(a.attributes["class"] ?? "")
+	const row = rowNode(e) && !(!["tr", "td", "th"].includes(e.tag) && !e.attributes["role"] && radii(e).some((r) => r > 0))
+	const rowHosts = row ? hosts.filter(rowNode) : [e]
+	if (rowHosts.some(selected) || (!row && (borderSafe.has(e.tag) || context(s, e, selected)))) return []
+	const status = rowHosts.some(
+		(a) =>
+			a.attributes["data-state"] !== undefined ||
+			a.attributes["data-status"] !== undefined ||
+			a.attributes["aria-invalid"] === "true" ||
+			/(?:is-|has-|--)[a-z]/.test(a.attributes["class"] ?? ""),
+	)
+	const bg = parseColor(styleOf(e, "background-color"))
+	const bare = (bg === null || bg.a < 0.1) && ["none", ""].includes(styleOf(e, "background-image"))
+	const shadows = parseShadow(styleOf(e, "box-shadow"))
+	const inset = shadows.length === 1 ? shadows[0] : undefined
+	if (
+		inset?.inset &&
+		inset.blur === 0 &&
+		inset.spread === 0 &&
+		chroma("rgb(" + inset.color.r + " " + inset.color.g + " " + inset.color.b + " / " + inset.color.a + ")")
+	) {
+		const axis = inset.x !== 0 && inset.y === 0 ? (inset.x > 0 ? 3 : 1) : inset.y !== 0 && inset.x === 0 ? (inset.y > 0 ? 0 : 2) : -1
+		const w = Math.max(Math.abs(inset.x), Math.abs(inset.y))
+		if (axis >= 0 && (row ? (axis === 1 || axis === 3) && w >= 2 && w <= 6 && (status || bare) : w >= 3 && w <= 12 && roundedAway(e, axis)))
+			return [{ element: e, message: "Inset accent stripe (" + w + "px)", snippet: shortSnippet(e) }]
+	}
+	if (row && (status || bare)) {
+		const drawn = sides.map(
+			(side) =>
+				length(styleOf(e, "border-" + side + "-width")) > 0 && !["none", "hidden", ""].includes(styleOf(e, "border-" + side + "-style")),
+		)
+		for (const i of [3, 1]) {
+			const side = sides[i] ?? "left",
+				w = length(styleOf(e, "border-" + side + "-width"))
+			if (drawn[0] && drawn[2]) continue
+			if (drawn[i] && w >= 2 && w <= 6 && chroma(styleOf(e, "border-" + side + "-color")) && (status || drawn.filter(Boolean).length === 1))
+				return [{ element: e, message: "Row accent border (" + w + "px)", snippet: shortSnippet(e) }]
+		}
+	}
+	if (!row && !borderSafe.has(e.tag)) {
+		const stripes = [e.before, e.after].flatMap((p) =>
+			p ? [{ style: p.style, width: length(p.style["width"] ?? ""), height: length(p.style["height"] ?? "") }] : [],
+		)
+		for (const p of stripes) {
+			if (
+				!["absolute", "fixed"].includes(p.style["position"] ?? "") ||
+				!chroma(p.style["background-color"] ?? "") ||
+				p.style["display"] === "none" ||
+				Number(p.style["opacity"] ?? 1) <= 0.01
+			)
+				continue
+			const hugs = (side: string): boolean => Math.abs(length(p.style[side] ?? "")) <= 2
+			const axis =
+				p.width >= 2 && p.width <= 12 && p.height >= Math.max(e.rect.height - 44, e.rect.height / 2)
+					? hugs("left")
+						? 3
+						: hugs("right")
+							? 1
+							: -1
+					: p.height >= 3 && p.height <= 12 && p.width >= Math.max(e.rect.width - 44, e.rect.width / 2)
+						? hugs("top")
+							? 0
+							: hugs("bottom")
+								? 2
+								: -1
+						: -1
+			if (axis >= 0 && roundedAway(e, axis)) return [{ element: e, message: "Positioned accent stripe", snippet: shortSnippet(e) }]
+		}
+	}
+	return []
+}
+
+export function childStripeHit(s: PageSnapshot, e: ElementSnapshot): PageHit[] {
+	if (!["div", "span"].includes(e.tag) || e.children.length > 0 || e.text.trim() !== "" || !visible(s, e)) return []
+	const p = parentOf(s, e)
+	if (!p || ["body", "html", "h1", "h2", "h3", "h4", "h5", "h6"].includes(p.tag) || p.rect.width < 40 || p.rect.height < 20) return []
+	if (
+		context(
+			s,
+			e,
+			(a) =>
+				["nav", "blockquote", "pre", "table", "button", "a", "select", "progress", "meter"].includes(a.tag) ||
+				["progressbar", "slider", "scrollbar", "separator", "tablist", "status", "alert"].includes(a.attributes["role"] ?? "") ||
+				selected(a),
+		)
+	)
+		return []
+	const { width: w, height: h, x } = e.rect,
+		host = p.rect
+	const side = Math.abs(x - host.x) <= 3 ? 3 : Math.abs(host.x + host.width - x - w) <= 3 ? 1 : -1
+	if (
+		side < 0 ||
+		w < 2 ||
+		w > 12 ||
+		h < Math.max(host.height - 44, host.height * 0.5) ||
+		!roundedAway(p, side) ||
+		!chroma(styleOf(e, "background-color"))
+	)
+		return []
+	return [{ element: e, message: w + "px accent stripe child", snippet: shortSnippet(e) }]
+}