Skip to content

code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ulw-research

ulw-research

Unverified

Runs 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.

FileKindSize
AGENTS.mdmarkdown9.2 KB
ATTRIBUTION.mdmarkdown2.4 KB
SKILL.mdskill md42.2 KB
references/deliverable-phase.mdmarkdown49.1 KB
references/fact-ledger-grammar.mdmarkdown6.8 KB
references/fact-ledger.mdmarkdown24.4 KB
references/fidelity-claim-kinds.mdmarkdown5.2 KB
references/markdown-blocks.mdmarkdown721 B
references/report-gates.mdmarkdown32.0 KB
references/report-visualization.mdmarkdown15.4 KB
references/research-collection.mdmarkdown26.8 KB
references/research-delivery.mdmarkdown14.3 KB
references/unit-rules.mdmarkdown16.3 KB
scripts/claim-kinds.mjsscript11.2 KB
scripts/claim-kinds.test.tsscript13.5 KB
scripts/claim-prefix.test.tsscript4.9 KB
scripts/claims-index.mjsscript5.3 KB
scripts/claims-index.test.tsscript5.7 KB
scripts/cli-support.mjsscript4.1 KB
scripts/cli-support.test.tsscript4.3 KB
scripts/contracts-validation.test.tsscript3.3 KB
scripts/contracts.mjsscript26.1 KB
scripts/contracts.test.tsscript7.9 KB
scripts/conversion-altered.test.tsscript11.0 KB
scripts/conversion-originals.test.tsscript22.7 KB
scripts/conversion-probe-classes.test.tsscript45.2 KB
scripts/conversion-probe.mjsscript13.5 KB
scripts/conversion-probe.test.tsscript11.6 KB
scripts/copy-returns-fidelity-policy.test.tsscript10.4 KB
scripts/copy-returns-polish.test.tsscript12.1 KB
scripts/copy-returns.test.tsscript10.6 KB
scripts/css-hiding.mjsscript9.1 KB
scripts/css-lite.mjsscript7.6 KB
scripts/css-lite.test.tsscript6.4 KB
scripts/delivery-barrier-meaning.test.tsscript12.3 KB
scripts/delivery-barrier.test.tsscript11.4 KB
scripts/design-spec.mjsscript7.2 KB
scripts/design-spec.test.tsscript6.7 KB
scripts/entities.mjsscript2.5 KB
scripts/entry-guard.mjsscript794 B
scripts/fact-commands-fill.mjsscript6.6 KB
scripts/fact-commands-meaning.mjsscript12.6 KB
scripts/fact-commands-polish.mjsscript10.3 KB
scripts/fact-commands-verify.mjsscript12.6 KB
scripts/fact-commands.mjsscript13.8 KB
scripts/fact-derive-2.test.tsscript7.2 KB
scripts/fact-derive.mjsscript4.9 KB
scripts/fact-derive.test.tsscript10.8 KB
scripts/fact-expr.mjsscript4.5 KB
scripts/fact-fill.mjsscript11.7 KB
scripts/fact-fill.test.tsscript10.7 KB
scripts/fact-ledger-grammar.test.tsscript11.8 KB
scripts/fact-ledger-kinds.mjsscript16.5 KB
scripts/fact-ledger-kinds.test.tsscript9.3 KB
scripts/fact-ledger-legacy.test.tsscript8.9 KB
scripts/fact-ledger-schema.mjsscript11.9 KB
scripts/fact-ledger-schema.test.tsscript1.5 KB
scripts/fact-ledger.mjsscript5.5 KB
scripts/fact-ledger.test.tsscript9.7 KB
scripts/fact-locate.mjsscript12.1 KB
scripts/fact-locate.test.tsscript7.2 KB
scripts/fact-pairs.mjsscript8.3 KB
scripts/fact-pairs.test.tsscript6.6 KB
scripts/fact-recompute.mjsscript4.8 KB
scripts/fact-unit-dimensions-2.test.tsscript8.4 KB
scripts/fact-unit-dimensions.test.tsscript11.9 KB
scripts/fact-unit-rules.test.tsscript8.9 KB
scripts/fidelity-binding.mjsscript6.7 KB
scripts/fidelity-binding.test.tsscript4.0 KB
scripts/fidelity-brief.mjsscript6.4 KB
scripts/fidelity-brief.test.tsscript7.8 KB
scripts/fidelity-claims.mjsscript5.1 KB
scripts/fidelity-csv.mjsscript1.1 KB
scripts/fidelity-lexicon.mjsscript8.1 KB
scripts/fidelity-lexicon.test.tsscript6.0 KB
scripts/fidelity-originals.mjsscript9.9 KB
scripts/fidelity-policy.mjsscript10.1 KB
scripts/fidelity-records.mjsscript13.4 KB
scripts/fidelity-snapshot-readability.mjsscript2.2 KB
scripts/fidelity-sources.mjsscript4.3 KB
scripts/fidelity-state.mjsscript2.1 KB
scripts/fidelity-state.test.tsscript1.7 KB
scripts/fidelity-trace.mjsscript6.1 KB
scripts/fidelity-trace.test.tsscript3.3 KB
scripts/fidelity-value-unit.mjsscript13.3 KB
scripts/fidelity-values.mjsscript16.1 KB
scripts/fidelity-values.test.tsscript15.8 KB
scripts/format-extract-css.mjsscript5.1 KB
scripts/format-extract.mjsscript10.3 KB
scripts/format-extract.test.tsscript11.2 KB
scripts/gates-context.test.tsscript2.6 KB
scripts/gates-fidelity.mjsscript6.3 KB
scripts/gates-fidelity.test.tsscript3.3 KB
scripts/gates-figures.mjsscript9.9 KB
scripts/gates-layout.mjsscript6.6 KB
scripts/gates-layout.test.tsscript12.4 KB
scripts/gates-static-headings.test.tsscript961 B
scripts/gates-static.mjsscript8.1 KB
scripts/gates-static.test.tsscript14.9 KB
scripts/gates-structure.mjsscript4.7 KB
scripts/gates-text.mjsscript7.2 KB
scripts/glossary-vocabulary.test.tsscript1.7 KB
scripts/html-foreign-object.mjsscript2.8 KB
scripts/html-lite.mjsscript9.7 KB
scripts/html-lite.test.tsscript7.9 KB
scripts/html-markup.mjsscript7.0 KB
scripts/html-text-map.mjsscript4.8 KB
scripts/html-text-map.test.tsscript15.2 KB
scripts/layout-probe.mjsscript4.6 KB
scripts/layout-probe.test.tsscript4.2 KB
scripts/lexicon.mjsscript2.6 KB
scripts/lexicon.test.tsscript3.2 KB
scripts/markdown-closers.mjsscript4.9 KB
scripts/md-lite-boundaries.test.tsscript2.2 KB
scripts/md-lite.mjsscript7.8 KB
scripts/md-lite.test.tsscript10.3 KB
scripts/meaning-check.mjsscript9.7 KB
scripts/meaning-check.test.tsscript12.0 KB
scripts/number-grammar.mjsscript2.1 KB
scripts/number-grammar.test.tsscript1.8 KB
scripts/numerals.mjsscript12.0 KB
scripts/numerals.test.tsscript6.1 KB
scripts/outcome-start.mjsscript3.8 KB
scripts/outcome-start.test.tsscript5.0 KB
scripts/outcome.mjsscript10.5 KB
scripts/outcome.test.tsscript12.8 KB
scripts/page-source-locator.test.tsscript11.7 KB
scripts/particles-ko.mjsscript4.8 KB
scripts/particles-ko.test.tsscript4.3 KB
scripts/placeholder.mjsscript9.3 KB
scripts/placeholder.test.tsscript3.8 KB
scripts/polish-apply.mjsscript6.8 KB
scripts/polish-apply.test.tsscript19.7 KB
scripts/polish-diff.mjsscript1.7 KB
scripts/polish-diff.test.tsscript10.1 KB
scripts/polish-markup.test.tsscript14.0 KB
scripts/polish-partial.test.tsscript2.5 KB
scripts/polish-project.mjsscript5.8 KB
scripts/polish-rules.mjsscript9.8 KB
scripts/rational.mjsscript5.2 KB
scripts/rational.test.tsscript1.9 KB
scripts/raw-decode.mjsscript4.5 KB
scripts/raw-locator.mjsscript2.4 KB
scripts/raw-snapshot.test.tsscript7.3 KB
scripts/references-fences.test.tsscript1.2 KB
scripts/repair-tracker.mjsscript7.5 KB
scripts/repair-tracker.test.tsscript10.8 KB
scripts/report-tools-2.test.tsscript16.1 KB
scripts/report-tools-3.test.tsscript9.3 KB
scripts/report-tools-4.test.tsscript10.1 KB
scripts/report-tools-5.test.tsscript14.6 KB
scripts/report-tools-commands.mjsscript12.9 KB
scripts/report-tools.mjsscript2.6 KB
scripts/report-tools.test.tsscript12.1 KB
scripts/sentence-split.mjsscript3.0 KB
scripts/sentence-split.test.tsscript4.5 KB
scripts/snapshot-readability.test.tsscript7.0 KB
scripts/source-commands.mjsscript12.4 KB
scripts/source-integrity.test.tsscript18.1 KB
scripts/source-refresh.mjsscript5.2 KB
scripts/source-snapshot.mjsscript9.9 KB
scripts/source-snapshot.test.tsscript6.3 KB
scripts/source-view.mjsscript5.0 KB
scripts/sources-citation.mjsscript12.1 KB
scripts/sources-citation.test.tsscript14.8 KB
scripts/tests/contracts-support.tsscript3.5 KB
scripts/tests/delivery-barrier-session.tsscript3.3 KB
scripts/tests/derive-clock.tsscript341 B
scripts/tests/fact-derive-support.tsscript1.9 KB
scripts/tests/fact-unit-dimensions-support.tsscript1.5 KB
scripts/tests/fact-unit-rules-support.tsscript16.8 KB
scripts/tests/fidelity-values-support.tsscript1.6 KB
scripts/tests/fixtures/assets/figure-1.svgother141 B
scripts/tests/fixtures/bad-report.htmlother2.1 KB
scripts/tests/fixtures/boxes.jsonconfig3.2 KB
scripts/tests/fixtures/conversion-probe.htmlother485 B
scripts/tests/fixtures/design-spec.mdmarkdown458 B
scripts/tests/fixtures/fidelity-brief-locked.mdmarkdown571 B
scripts/tests/fixtures/fidelity-brief-pending.mdmarkdown574 B
scripts/tests/fixtures/fidelity/assets/share.csvother40 B
scripts/tests/fixtures/fidelity/claim-graph.mdmarkdown449 B
scripts/tests/fixtures/fidelity/gen-legacy-dev.mjsscript5.0 KB
scripts/tests/fixtures/fidelity/ledger-basic.jsonconfig5.1 KB
scripts/tests/fixtures/fidelity/ledger-legacy-dev.jsonconfig18.3 KB
scripts/tests/fixtures/fidelity/ledger-verify.jsonconfig9.1 KB
scripts/tests/fixtures/fidelity/polish-edits.jsonconfig303 B
scripts/tests/fixtures/fidelity/report-bad.htmlother821 B
scripts/tests/fixtures/fidelity/report-good.htmlother2.4 KB
scripts/tests/fixtures/fidelity/sources/S4.htmlother680 B
scripts/tests/fixtures/fidelity/sources/S4/acronyms.jsonconfig36 B
scripts/tests/fixtures/fidelity/sources/S4/meta.jsonconfig256 B
scripts/tests/fixtures/fidelity/sources/S4/sentences.jsonlother623 B
scripts/tests/fixtures/fidelity/sources/S4/text.txtmarkdown300 B
scripts/tests/fixtures/fidelity/sources/S5/acronyms.jsonconfig3 B
scripts/tests/fixtures/fidelity/sources/S5/meta.jsonconfig235 B
scripts/tests/fixtures/fidelity/sources/S5/sentences.jsonlother53 B
scripts/tests/fixtures/fidelity/sources/S5/text.txtmarkdown10 B
scripts/tests/fixtures/fidelity/sources/S9.txtmarkdown128 B
scripts/tests/fixtures/good-report.htmlother2.7 KB
scripts/tests/fixtures/reference-report.htmlother2.5 KB

scripts/gates-layout.test.ts

View on GitHub
import { 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"])
  })
})
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
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: 198kUpdated Claude CodeCodexVerifiedInstall