lazycodex-ai 5.1.48 → 5.1.54

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

@@ -0,0 +1,66 @@
+import { ancestors, parentOf } from "../../../core/page"
+import { cssBlocks } from "../../../core/source"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+
+function compound(e: ElementSnapshot, selector: string): boolean {
+	const tag = /^[a-z][\w-]*|^\*/i.exec(selector)?.[0]
+	if (tag && tag !== "*" && e.tag !== tag.toLowerCase()) return false
+	let rest = selector.slice(tag?.length ?? 0)
+	for (const m of rest.matchAll(/([.#])([\w-]+)|\[([\w-]+)(?:=["']?([^"'\]]*)["']?)?\]/g)) {
+		if (m[1] === "#" && e.attributes["id"] !== m[2]) return false
+		if (m[1] === "." && !(e.attributes["class"] ?? "").split(/\s+/).includes(m[2] ?? "")) return false
+		if (m[3] && (e.attributes[m[3]] === undefined || (m[4] !== undefined && e.attributes[m[3]] !== m[4]))) return false
+	}
+	rest = rest.replace(/([.#])[\w-]+|\[[^\]]+\]/g, "")
+	return rest === ""
+}
+
+export function matchesSelector(s: PageSnapshot, e: ElementSnapshot, selector: string): boolean {
+	const pieces = selector.trim().replace(/\s*>\s*/g, " > ").split(/\s+/)
+	const last = pieces.pop()
+	if (!last || !compound(e, last)) return false
+	let current = e
+	while (pieces.length > 0) {
+		const part = pieces.pop()
+		if (part === ">") {
+			const parent = parentOf(s, current)
+			const wanted = pieces.pop()
+			if (!parent || !wanted || !compound(parent, wanted)) return false
+			current = parent
+		} else {
+			const match = [...ancestors(s, current)].find(a => compound(a, part ?? ""))
+			if (!match) return false
+			current = match
+		}
+	}
+	return true
+}
+
+export function cssCandidates(s: PageSnapshot): ReadonlyMap<string, Readonly<Record<string, string>>> {
+	const merged = new Map<string, Record<string, string>>()
+	for (const css of s.cssText) {
+		let text = css
+		for (const match of css.matchAll(/@media[^{]*prefers-reduced-motion\s*:\s*reduce\s*\)[^{]*\{/g)) {
+			let end = (match.index ?? 0) + match[0].length
+			let depth = 1
+			const start = match.index ?? 0
+			while (end < css.length && depth > 0) {
+				if (css[end] === "{") depth++
+				if (css[end] === "}") depth--
+				end++
+			}
+			text = text.replace(css.slice(start, end), "")
+		}
+		for (const block of cssBlocks(text)) {
+			for (const selector of block.selector.split(",").map(v => v.trim()).filter(v => v !== "" && !v.startsWith("@"))) {
+				const declarations = merged.get(selector) ?? {}
+				for (const entry of block.body.split(";")) {
+					const colon = entry.indexOf(":")
+					if (colon >= 0) declarations[entry.slice(0, colon).trim().toLowerCase()] = entry.slice(colon + 1).trim()
+				}
+				merged.set(selector, declarations)
+			}
+		}
+	}
+	return merged
+}

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

@@ -0,0 +1,55 @@
+export type Point = readonly [number, number]
+export const lerp = (a: Point, b: Point, t: number): Point => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
+export function cubic(p0: Point, p1: Point, p2: Point, p3: Point): readonly Point[] {
+	return Array.from({ length: 15 }, (_, i) => {
+		const t = (i + 1) / 16,
+			u = 1 - t,
+			a = u * u * u,
+			b = 3 * u * u * t,
+			c = 3 * u * t * t,
+			d = t * t * t
+		return [a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]] satisfies Point
+	})
+}
+export function arc(
+	from: Point,
+	rxInput: number,
+	ryInput: number,
+	rotation: number,
+	large: boolean,
+	sweep: boolean,
+	to: Point,
+): readonly Point[] {
+	let rx = Math.abs(rxInput),
+		ry = Math.abs(ryInput)
+	if ((from[0] === to[0] && from[1] === to[1]) || rx === 0 || ry === 0) return []
+	const phi = (rotation * Math.PI) / 180,
+		sin = Math.sin(phi),
+		cos = Math.cos(phi),
+		dx = (from[0] - to[0]) / 2,
+		dy = (from[1] - to[1]) / 2
+	const x1 = cos * dx + sin * dy,
+		y1 = -sin * dx + cos * dy,
+		lambda = (x1 * x1) / (rx * rx) + (y1 * y1) / (ry * ry)
+	if (lambda > 1) {
+		rx *= Math.sqrt(lambda)
+		ry *= Math.sqrt(lambda)
+	}
+	const num = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1,
+		den = rx * rx * y1 * y1 + ry * ry * x1 * x1
+	const coef = (den === 0 ? 0 : Math.sqrt(Math.max(0, num / den))) * (large === sweep ? -1 : 1)
+	const cx1 = (coef * rx * y1) / ry,
+		cy1 = (-coef * ry * x1) / rx,
+		cx = cos * cx1 - sin * cy1 + (from[0] + to[0]) / 2,
+		cy = sin * cx1 + cos * cy1 + (from[1] + to[1]) / 2
+	const theta = Math.atan2((y1 - cy1) / ry, (x1 - cx1) / rx)
+	let delta = Math.atan2((-y1 - cy1) / ry, (-x1 - cx1) / rx) - theta
+	if (sweep && delta < 0) delta += Math.PI * 2
+	else if (!sweep && delta > 0) delta -= Math.PI * 2
+	return Array.from({ length: 15 }, (_, i) => {
+		const t = theta + (delta * (i + 1)) / 16,
+			ex = rx * Math.cos(t),
+			ey = ry * Math.sin(t)
+		return [cos * ex - sin * ey + cx, sin * ex + cos * ey + cy] satisfies Point
+	})
+}

package/packages/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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` }]
+	},
+}