code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ulw-research
ulw-research
UnverifiedRuns maximum-saturation research with a cooperating team, claim-graph gating, and a cited, QA'd deliverable. Use when the user explicitly asks for research or a deep investigation, including any 'ulw' research wording.
scripts/gates-layout.test.ts
View on GitHubimport { describe, expect, test } from "bun:test"
import { readFileSync } from "node:fs"
import path from "node:path"
import { fileURLToPath } from "node:url"
import { DEFECT_CODES, LAYOUT_CODES } from "./contracts.mjs"
import { checkLayout } from "./gates-layout.mjs"
import { ProbeError } from "./layout-probe.mjs"
const FIXTURE_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "tests", "fixtures", "boxes.json")
const PARENT = "body > main > section"
const PARENT_RECT = { x: 0, y: 0, w: 600, h: 400 }
type Size = { w: number; h: number }
type Box = ReturnType<typeof box>
function box(overrides: Record<string, unknown> = {}) {
return {
selector: `${PARENT} > p`,
tag: "p",
rect: { x: 10, y: 10, w: 100, h: 20 },
parentSelector: PARENT,
parentRect: PARENT_RECT,
scroll: { sw: 100, cw: 100, sh: 20, ch: 20 },
overflow: { x: "visible", y: "visible" },
position: "static",
textLen: 10,
...overrides,
}
}
function img(rect: Size, natural: Size, overrides: Record<string, unknown> = {}) {
return box({
selector: `${PARENT} > figure > img`,
tag: "img",
rect: { x: 0, y: 0, ...rect },
textLen: 0,
objectFit: "fill",
natural,
...overrides,
})
}
function probe(boxes: Box[], overrides: Record<string, unknown> = {}) {
return {
probe_version: 1,
viewport: { w: 1280, h: 900 },
document: { w: 1280, h: 2000 },
count: boxes.length,
truncated: false,
boxes,
...overrides,
}
}
function codes(result: ReturnType<typeof checkLayout>) {
return result.defects.map((defect) => defect.code)
}
describe("checkLayout L1 overflow", () => {
test("#given a child spilling 3px past the right edge of its parent #when checked #then layout_overflow is raised with the contract severity", () => {
// given
const child = box({ rect: { x: 500, y: 10, w: 103, h: 20 } })
// when
const result = checkLayout(probe([child]))
// then
expect(codes(result)).toEqual(["layout_overflow"])
expect(result.defects[0].severity).toBe(DEFECT_CODES.layout_overflow.severity)
expect(result.defects[0].selector).toBe(child.selector)
expect(result.defects[0].hint).toBe(DEFECT_CODES.layout_overflow.hint)
expect(result.defects[0].message).toContain("3px")
})
test("#given a child spilling exactly 2px #when checked #then no defect is raised", () => {
expect(checkLayout(probe([box({ rect: { x: 500, y: 10, w: 102, h: 20 } })])).defects).toEqual([])
})
test("#given a 2px spill that float arithmetic on 0.1px probe values turns into 2.000000000000001 #when checked #then no defect is raised", () => {
// given
const child = box({ rect: { x: 0.1, y: 0, w: 9.8, h: 5 }, parentRect: { x: 0.1, y: 0, w: 7.8, h: 20 } })
expect(child.rect.x + child.rect.w - (child.parentRect.x + child.parentRect.w)).toBeGreaterThan(2)
// when / then
expect(checkLayout(probe([child])).defects).toEqual([])
})
test("#given a child spilling 3px past the top edge #when checked #then layout_overflow is raised", () => {
expect(codes(checkLayout(probe([box({ rect: { x: 10, y: -3, w: 100, h: 20 } })])))).toEqual(["layout_overflow"])
})
test("#given absolute and fixed children spilling 50px #when checked #then they are exempt", () => {
const boxes = ["absolute", "fixed"].map((position, i) =>
box({
selector: `${PARENT} > div:nth-of-type(${i + 1}) > p`,
parentSelector: `${PARENT} > div:nth-of-type(${i + 1})`,
rect: { x: 580, y: 10, w: 70, h: 20 },
position,
}),
)
expect(checkLayout(probe(boxes)).defects).toEqual([])
})
test("#given a box with no parent rect #when checked #then L1 is skipped without throwing", () => {
expect(checkLayout(probe([box({ parentSelector: null, parentRect: null })])).defects).toEqual([])
})
})
describe("checkLayout L2 and L3 scroll inequality", () => {
test("#given text wider than its box by 3px under overflow hidden #when checked #then layout_text_clipped is raised", () => {
const clipped = box({ scroll: { sw: 103, cw: 100, sh: 20, ch: 20 }, overflow: { x: "hidden", y: "visible" } })
const result = checkLayout(probe([clipped]))
expect(codes(result)).toEqual(["layout_text_clipped"])
expect(result.defects[0].severity).toBe(DEFECT_CODES.layout_text_clipped.severity)
})
test("#given text taller than its box by 3px under overflow clip #when checked #then layout_text_clipped is raised", () => {
const clipped = box({ scroll: { sw: 100, cw: 100, sh: 23, ch: 20 }, overflow: { x: "visible", y: "clip" } })
expect(codes(checkLayout(probe([clipped])))).toEqual(["layout_text_clipped"])
})
test("#given a 2px excess under overflow hidden #when checked #then no defect is raised", () => {
const edge = box({ scroll: { sw: 102, cw: 100, sh: 22, ch: 20 }, overflow: { x: "hidden", y: "hidden" } })
expect(checkLayout(probe([edge])).defects).toEqual([])
})
test("#given a pre that scrolls horizontally under overflow auto #when checked #then minor layout_scroll_container is raised", () => {
const scroller = box({
selector: `${PARENT} > pre`,
tag: "pre",
scroll: { sw: 812, cw: 550, sh: 156, ch: 156 },
overflow: { x: "auto", y: "auto" },
})
const result = checkLayout(probe([scroller]))
expect(codes(result)).toEqual(["layout_scroll_container"])
expect(result.defects[0].severity).toBe(DEFECT_CODES.layout_scroll_container.severity)
})
test("#given content overflowing a visible box #when checked #then neither L2 nor L3 fires", () => {
const visible = box({ scroll: { sw: 300, cw: 100, sh: 90, ch: 20 } })
expect(checkLayout(probe([visible])).defects).toEqual([])
})
})
describe("checkLayout L4 image distortion", () => {
test("#given an img rendered 300x150 with natural 300x160 #when checked #then layout_image_distorted names 6.7%", () => {
const result = checkLayout(probe([img({ w: 300, h: 150 }, { w: 300, h: 160 })]))
expect(codes(result)).toEqual(["layout_image_distorted"])
expect(result.defects[0].severity).toBe(DEFECT_CODES.layout_image_distorted.severity)
expect(result.defects[0].message).toContain("6.7%")
})
test("#given an img rendered 300x150 with natural 300x154 (under 3% drift) #when checked #then no defect is raised", () => {
expect(checkLayout(probe([img({ w: 300, h: 150 }, { w: 300, h: 154 })])).defects).toEqual([])
})
test("#given a distorted img under object-fit cover, contain, or scale-down #when checked #then it is exempt", () => {
const boxes = ["cover", "contain", "scale-down"].map((objectFit, i) =>
img(
{ w: 300, h: 150 },
{ w: 300, h: 300 },
{
objectFit,
selector: `${PARENT} > figure:nth-of-type(${i + 1}) > img`,
parentSelector: `${PARENT} > figure:nth-of-type(${i + 1})`,
},
),
)
expect(checkLayout(probe(boxes)).defects).toEqual([])
})
test("#given an img whose natural size is 0x0 (not loaded) #when checked #then it is skipped without throwing", () => {
expect(() => checkLayout(probe([img({ w: 300, h: 150 }, { w: 0, h: 0 })]))).not.toThrow()
expect(checkLayout(probe([img({ w: 300, h: 150 }, { w: 0, h: 0 })])).defects).toEqual([])
})
test("#given an img with a zero rendered height #when checked #then it is skipped", () => {
expect(checkLayout(probe([img({ w: 300, h: 0 }, { w: 300, h: 160 })])).defects).toEqual([])
})
})
describe("checkLayout L5 sibling overlap", () => {
const first = box({ selector: `${PARENT} > p:nth-of-type(1)`, rect: { x: 0, y: 0, w: 100, h: 100 } })
test("#given two static siblings intersecting 13x13 #when checked #then layout_sibling_overlap names both selectors", () => {
const second = box({
selector: `${PARENT} > p:nth-of-type(2)`,
rect: { x: 87, y: 87, w: 100, h: 100 },
position: "relative",
})
const result = checkLayout(probe([first, second]))
expect(codes(result)).toEqual(["layout_sibling_overlap"])
expect(result.defects[0].severity).toBe(DEFECT_CODES.layout_sibling_overlap.severity)
expect(result.defects[0].message).toContain(first.selector)
expect(result.defects[0].message).toContain(second.selector)
})
test("#given two siblings intersecting 12x40 #when checked #then no defect is raised", () => {
const second = box({ selector: `${PARENT} > p:nth-of-type(2)`, rect: { x: 88, y: 60, w: 100, h: 100 } })
expect(checkLayout(probe([first, second])).defects).toEqual([])
})
test("#given a 13x13 intersection where one box is absolute #when checked #then it is exempt", () => {
const badge = box({
selector: `${PARENT} > p:nth-of-type(2)`,
rect: { x: 87, y: 87, w: 100, h: 100 },
position: "absolute",
})
expect(checkLayout(probe([first, badge])).defects).toEqual([])
})
test("#given a 13x13 intersection between boxes of different parents #when checked #then it is not a sibling overlap", () => {
const cousin = box({
selector: "body > main > div > p",
parentSelector: "body > main > div",
rect: { x: 87, y: 87, w: 100, h: 100 },
parentRect: { x: 0, y: 0, w: 600, h: 400 },
})
expect(checkLayout(probe([first, cousin])).defects).toEqual([])
})
})
describe("checkLayout probe validation and summary", () => {
test("#given probe_version 2 #when checked #then a typed ProbeError is thrown", () => {
expect(() => checkLayout(probe([], { probe_version: 2 }))).toThrow(ProbeError)
try {
checkLayout(probe([], { probe_version: 2 }))
} catch (error) {
expect((error as ProbeError).code).toBe("unsupported_probe_version")
}
})
test("#given a probe without a boxes array #when checked #then a typed ProbeError is thrown", () => {
const malformed = JSON.parse('{"probe_version": 1}')
expect(() => checkLayout(malformed)).toThrow(ProbeError)
})
test("#given a truncated probe #when checked #then the summary ends with the truncation note", () => {
const result = checkLayout(probe([box()], { count: 500, truncated: true }))
expect(result.summary.endsWith("layout sample truncated")).toBe(true)
})
test("#given a complete probe #when checked #then the summary carries no truncation note", () => {
expect(checkLayout(probe([box()])).summary).not.toContain("truncated")
})
test("#given every defect raised across the rules #when inspected #then each code is a LAYOUT_CODES entry", () => {
const boxes = [
box({ rect: { x: 590, y: 10, w: 20, h: 20 } }),
box({
selector: `${PARENT} > h2`,
scroll: { sw: 130, cw: 100, sh: 20, ch: 20 },
overflow: { x: "hidden", y: "hidden" },
}),
img({ w: 300, h: 150 }, { w: 300, h: 300 }),
]
const raised = codes(checkLayout(probe(boxes)))
expect(raised.length).toBeGreaterThan(0)
expect(raised.every((code: string) => LAYOUT_CODES.includes(code))).toBe(true)
})
})
describe("checkLayout on the fixture sample", () => {
test("#given the boxes.json sample with the two measured real-sample images #when checked #then only the pre scroll container is reported", () => {
// given
const sample = JSON.parse(readFileSync(FIXTURE_PATH, "utf8"))
// when
const result = checkLayout(sample)
// then
expect(result.defects.map((defect) => [defect.code, defect.selector])).toEqual([
["layout_scroll_container", "#method > pre"],
])
expect(result.summary).not.toContain("truncated")
})
})
describe("checkLayout L1 inside a scrolling or clipping parent", () => {
const wideTable = (parentOverflow?: { x: string; y: string }) =>
box({
selector: `${PARENT} > div > table`,
tag: "table",
rect: { x: 0, y: 10, w: 816, h: 200 },
parentSelector: `${PARENT} > div`,
...(parentOverflow ? { parentOverflow } : {}),
})
test("#given a table spilling 216px inside a parent with overflow-x auto #when checked #then it is the advisory scroll container, not an overflow", () => {
const result = checkLayout(probe([wideTable({ x: "auto", y: "visible" })]))
expect(codes(result)).toEqual(["layout_scroll_container"])
expect(result.defects[0]?.severity).toBe(DEFECT_CODES.layout_scroll_container.severity)
})
test("#given the same spill inside a parent with overflow-x hidden #when checked #then the content is reported clipped", () => {
expect(codes(checkLayout(probe([wideTable({ x: "hidden", y: "visible" })])))).toEqual(["layout_text_clipped"])
})
test("#given the same spill with no parentOverflow recorded #when checked #then it stays a layout_overflow", () => {
expect(codes(checkLayout(probe([wideTable()])))).toEqual(["layout_overflow"])
})
})
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |