From ac4c1cc4afa554ee7d8fa7d49896c003077ca328 Mon Sep 17 00:00:00 2001 From: Nayan Date: Fri, 14 Aug 2026 13:22:50 +0530 Subject: [PATCH] fix(overlay): make the Stroke section answer for all four edges MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Every read in the section was `border-top-*` answering for the whole box, so `.header { border-bottom: 1px solid }` showed as unstroked and editing it wrote to the wrong edge. `edgeValue()` folds all four longhands through `agreed`, comparing colours with `sameColor` so one colour spelled two ways is not reported as Mixed. The eye was a live bug rather than a cosmetic one. Three writes still went through the `border-style` shorthand, while `hasStroke` reads longhands through `ctx.gate`, which does no shorthand expansion. A pending longhand `solid` therefore shadowed a shorthand `none` forever: the eye toggled, the gate kept reading `solid`, and nothing happened again. All three writes go through `writeAllEdges` now. `strokeColor` is passed as the colour row's re-seed reader for the same class of reason — without it the four registered properties push four `setValue` calls and `border-left-color` wins by arriving last. `splitBorder` had no first-wins guard on `width`, so `border: 1px solid var(--border)` let the `var()` overwrite `1px` and left the colour undefined entirely. The forced-state preview got `border-*-width: var(--border)` and no colour at all. First tests for `renderStroke`, covering all six defects, plus a `MixedEdges` story and the `mixedBorder` specimen it renders. --- .../overlay/src/inspector/cascade.test.ts | 49 ++++ packages/overlay/src/inspector/cascade.ts | 18 +- .../src/inspector/sections/stroke.stories.ts | 25 ++ .../src/inspector/sections/stroke.test.ts | 215 ++++++++++++++++++ .../overlay/src/inspector/sections/stroke.ts | 122 ++++++++-- packages/overlay/src/stories/subjects.test.ts | 1 + packages/overlay/src/stories/subjects.ts | 17 ++ 7 files changed, 433 insertions(+), 14 deletions(-) create mode 100644 packages/overlay/src/inspector/sections/stroke.test.ts diff --git a/packages/overlay/src/inspector/cascade.test.ts b/packages/overlay/src/inspector/cascade.test.ts index c57119d..69acbe7 100644 --- a/packages/overlay/src/inspector/cascade.test.ts +++ b/packages/overlay/src/inspector/cascade.test.ts @@ -104,6 +104,55 @@ describe("expandShorthands", () => { "padding-top": "4px", }); }); + + /* + * `border`'s three parts are order-independent and all optional, so each word + * is classified rather than positioned — and a `var()` is the one word that + * could be any of them. + * + * `LOOKS_LIKE_LENGTH` matches `^var\(`, which it has to: `border-width: + * var(--w)` is ordinary. But so is `border: 1px solid var(--border)`, and + * there the `var()` is the *colour*. With no guard the last matching word won, + * so `var(--border)` overwrote the `1px` and the colour was dropped entirely — + * a forced-state preview for such a rule got `border-*-width: var(--border)` + * and no colour at all. + */ + it("does not let a var() colour overwrite the border width", () => { + expect(expand({ border: "1px solid var(--border)" })).toEqual({ + "border-bottom-color": "var(--border)", + "border-bottom-style": "solid", + "border-bottom-width": "1px", + "border-left-color": "var(--border)", + "border-left-style": "solid", + "border-left-width": "1px", + "border-right-color": "var(--border)", + "border-right-style": "solid", + "border-right-width": "1px", + "border-top-color": "var(--border)", + "border-top-style": "solid", + "border-top-width": "1px", + }); + }); + + it("still reads a lone var() as the width, which is the ambiguous case", () => { + // Nothing in the string says which slot it fills, and first-wins puts it in + // the one a single `var()` most often means. + expect(expand({ "border-top": "var(--w) solid" })).toEqual({ + "border-top-style": "solid", + "border-top-width": "var(--w)", + }); + }); + + it("keeps a calc() width beside a var() colour", () => { + // `calc(` is in the same regex as `var(` and took the same wrong branch. + expect(expand({ "border-top": "calc(1px + 1px) dashed var(--c)" })).toEqual( + { + "border-top-color": "var(--c)", + "border-top-style": "dashed", + "border-top-width": "calc(1px + 1px)", + } + ); + }); }); describe("stripStates", () => { diff --git a/packages/overlay/src/inspector/cascade.ts b/packages/overlay/src/inspector/cascade.ts index a08e4bd..0acee4b 100644 --- a/packages/overlay/src/inspector/cascade.ts +++ b/packages/overlay/src/inspector/cascade.ts @@ -452,6 +452,19 @@ const LINE_STYLES = new Set([ * The three are order-independent and all optional, so each word is classified * rather than positioned: a line-style keyword is the style, something that parses as * a length (or a width keyword) is the width, and whatever is left is the colour. + * + * The `out.width === undefined` guard is what stops `var()` eating the colour. + * `LOOKS_LIKE_LENGTH` matches `^var\(` — it has to, because `border-width: + * var(--w)` is ordinary — but so is `border: 1px solid var(--border)`, and there + * the *colour* is the `var()`. With no guard the last matching word won, so + * `var(--border)` overwrote the `1px` and `out.color` was left undefined + * entirely: the forced-state preview for such a rule got `border-*-width: + * var(--border)` and no colour at all. + * + * A `var()` in this position is genuinely ambiguous — nothing in the string says + * which slot it fills. But a shorthand has at most one width, so first-wins is + * strictly better than last-wins: it keeps the unambiguous `1px` where it + * belongs and leaves the ambiguous word in the only slot still open. */ function splitBorder(value: string): { color?: string; @@ -463,7 +476,10 @@ function splitBorder(value: string): { const lower = word.toLowerCase(); if (LINE_STYLES.has(lower)) { out.style = lower; - } else if (WIDTH_KEYWORD.has(lower) || LOOKS_LIKE_LENGTH.test(word)) { + } else if ( + out.width === undefined && + (WIDTH_KEYWORD.has(lower) || LOOKS_LIKE_LENGTH.test(word)) + ) { out.width = word; } else { out.color = word; diff --git a/packages/overlay/src/inspector/sections/stroke.stories.ts b/packages/overlay/src/inspector/sections/stroke.stories.ts index 6eaad7d..037b3b3 100644 --- a/packages/overlay/src/inspector/sections/stroke.stories.ts +++ b/packages/overlay/src/inspector/sections/stroke.stories.ts @@ -97,3 +97,28 @@ export const Narrow: StoryObj = { narrow: true, }), }; + +/** + * Four edges that disagree — the specimen the catalogue was missing. + * + * None of the five stories above uses an element whose edges differ, which is + * why nothing here caught the section answering for the whole box from + * `border-top-*`. This one shows a red top, teal right, blue bottom and amber + * left: the colour row must read `Mixed` and the width field must open split. + * + * Two things to try, both of which used to be wrong. Picking a colour imposes + * it on all four edges — that is the point of `Mixed`, "several values, one of + * which you are about to impose". And the eye must still hide the stroke after + * `+` Add stroke has been pressed: it wrote the `border-style` shorthand while + * `hasStroke` reads the longhands through `ctx.gate`, so a pending `solid` + * shadowed it forever and the eye did nothing. + */ +export const MixedEdges: StoryObj = { + render: () => + sectionStory(renderStroke, "mixedBorder", { + caption: { + try: "pick a colour — it must land on all four edges; then press the eye, `+` Add stroke, and the eye again", + what: "Four differing edges. The colour row reads `Mixed` rather than claiming the top edge's red for the box.", + }, + }), +}; diff --git a/packages/overlay/src/inspector/sections/stroke.test.ts b/packages/overlay/src/inspector/sections/stroke.test.ts new file mode 100644 index 0000000..adc4447 --- /dev/null +++ b/packages/overlay/src/inspector/sections/stroke.test.ts @@ -0,0 +1,215 @@ +/** + * The Stroke section, on the four edges it speaks for. + * + * Nothing tested `renderStroke` at all, and it had six defects of one shape: it + * claimed things it did not do. Every *read* asked `border-top-*` and answered + * for the whole box — so `.header { border-bottom: 1px solid #eee }`, the + * canonical divider, showed as an unstroked element, and four differing edge + * colours showed as the top one. Three *writes* used the `border-style` + * shorthand while the file's own header claimed it never did, and one of those + * was live: `hasStroke` reads the longhands through `ctx.gate`, which does no + * shorthand expansion, so once *Add stroke* had written a pending `solid` the + * shorthand `none` could never win and the eye stopped working. + * + * The section is driven through a recording context rather than the full panel, + * for the reason `svg-paint.test.ts` gives: what matters is which properties + * the closures write, and a stub is the only way to see them. + */ +import { afterEach, describe, expect, it } from "vitest"; +import type { SectionContext } from "./context"; +import { renderStroke } from "./stroke"; + +afterEach(() => { + for (const child of Array.from(document.body.children)) { + child.remove(); + } +}); + +interface ColorRow { + onChange: (next: string) => void; + properties: readonly string[]; + /** The re-seed escape hatch. Absent is the bug this file was written for. */ + read?: () => string; + value: string; +} + +interface Recorded { + changes: [string, string][]; + colorRow: ColorRow | null; + reseeds: number; +} + +/** A SectionContext that records writes and captures the colour row's wiring. */ +function recordingCtx(): { ctx: SectionContext; got: Recorded } { + const got: Recorded = { changes: [], colorRow: null, reseeds: 0 }; + const stub = document.createElement("div"); + const ctx = { + colorRow: ( + value: string, + _tip: string, + onChange: (next: string) => void, + _node?: Element, + properties: readonly string[] = [], + read?: () => string + ) => { + got.colorRow = { onChange, properties, read, value }; + return stub.cloneNode() as HTMLElement; + }, + // The real gate is "pending edit, then computed style". Computed alone is + // enough here: happy-dom applies inline styles, and no test below has a + // pending edit the DOM has not already taken. + gate: (node: Element) => (property: string) => + getComputedStyle(node).getPropertyValue(property), + gestures: {}, + headerAction: () => stub.cloneNode() as HTMLElement, + onChange: (property: string, value: string) => { + got.changes.push([property, value]); + }, + register: () => undefined, + repaintScope: () => (paint: () => void) => paint(), + reseed: () => { + got.reseeds += 1; + }, + section: (_id: string, _label: string, body: HTMLElement) => body, + tokenSlot: () => null, + } as unknown as SectionContext; + return { ctx, got }; +} + +/** An element with a border, written per-edge so nothing is a shorthand. */ +function bordered(edges: Partial>): HTMLElement { + const node = document.createElement("div"); + for (const side of ["top", "right", "bottom", "left"]) { + node.style.setProperty(`border-${side}-style`, "solid"); + node.style.setProperty(`border-${side}-width`, "1px"); + node.style.setProperty( + `border-${side}-color`, + edges[side] ?? "rgb(0, 0, 0)" + ); + } + document.body.append(node); + return node; +} + +/** Click a button by its accessible name. */ +function press(root: HTMLElement, label: string): void { + const button = root.querySelector(`[aria-label="${label}"]`); + if (!button) { + throw new Error(`no "${label}" button`); + } + button.click(); +} + +describe("the colour row speaks for four edges", () => { + it("shows the shared colour when they agree", () => { + const { ctx, got } = recordingCtx(); + renderStroke(ctx, bordered({})); + expect(got.colorRow?.value).toBe("rgb(0, 0, 0)"); + }); + + it("shows Mixed when they do not", () => { + // Was: the top edge's colour, imposed on the other three by the first edit. + const { ctx, got } = recordingCtx(); + renderStroke( + ctx, + bordered({ bottom: "rgb(0, 0, 255)", top: "rgb(255, 0, 0)" }) + ); + expect(got.colorRow?.value).toBe("Mixed"); + }); + + it("does not call one colour Mixed for being spelled two ways", () => { + /* + * The reason this compares with `sameColor` rather than `===`. Once an edit + * is pending, `applyPreview` has written the picker's modern + * `rgb(r g b / a)` into the inline style of the edges just written while + * the rest still read back the engine's legacy form. String equality calls + * that a disagreement and shows `Mixed` on a box the user just made uniform. + */ + const node = bordered({}); + node.style.setProperty("border-top-color", "rgb(0 0 0 / 1)"); + const { ctx, got } = recordingCtx(); + renderStroke(ctx, node); + expect(got.colorRow?.value).not.toBe("Mixed"); + }); + + it("imposes a picked colour on all four edges", () => { + const { ctx, got } = recordingCtx(); + renderStroke(ctx, bordered({ top: "rgb(255, 0, 0)" })); + got.colorRow?.onChange("rgb(0, 255, 0)"); + expect(got.changes).toEqual([ + ["border-top-color", "rgb(0, 255, 0)"], + ["border-right-color", "rgb(0, 255, 0)"], + ["border-bottom-color", "rgb(0, 255, 0)"], + ["border-left-color", "rgb(0, 255, 0)"], + ]); + }); +}); + +describe("the re-seed escape hatch", () => { + it("is supplied, or the fix dies on the first refresh", () => { + /* + * The row registers four properties, and without a `read` the re-seed pass + * pushes the raw value of each in turn — so `border-left-color` wins and a + * `Mixed` row silently settles on the left edge after one undo. The + * assertion is on the wiring because that is where the bug lived. + */ + const { ctx, got } = recordingCtx(); + renderStroke( + ctx, + bordered({ bottom: "rgb(0, 0, 255)", top: "rgb(255, 0, 0)" }) + ); + expect(got.colorRow?.properties).toHaveLength(4); + expect(got.colorRow?.read).toBeTypeOf("function"); + }); + + it("re-derives the same value the seed did", () => { + // `vector.ts` states the invariant: the seed and the re-seed `read` have to + // agree, or the next refresh contradicts the render. + const { ctx, got } = recordingCtx(); + renderStroke( + ctx, + bordered({ bottom: "rgb(0, 0, 255)", top: "rgb(255, 0, 0)" }) + ); + expect(got.colorRow?.read?.()).toBe(got.colorRow?.value); + }); +}); + +describe("every write is a longhand", () => { + it("hides the stroke with four longhands, not the shorthand", () => { + /* + * The known bug. `hasStroke` reads per-edge `border--style` through + * `ctx.gate`, a per-property lookup with no shorthand expansion — so after + * *Add stroke* had written the longhands once, a pending `solid` on them + * shadowed the shorthand `none` forever and the eye was a no-op. + */ + const { ctx, got } = recordingCtx(); + const body = renderStroke(ctx, bordered({})); + press(body, "Hide stroke"); + expect(got.changes).toEqual([ + ["border-top-style", "none"], + ["border-right-style", "none"], + ["border-bottom-style", "none"], + ["border-left-style", "none"], + ]); + expect(got.changes.some(([p]) => p === "border-style")).toBe(false); + }); + + it("removes the stroke with longhands, as it always did", () => { + // The control this one was already modelled on. + const { ctx, got } = recordingCtx(); + const body = renderStroke(ctx, bordered({})); + press(body, "Remove stroke"); + expect(got.changes.map(([p]) => p)).toEqual([ + "border-top-style", + "border-right-style", + "border-bottom-style", + "border-left-style", + "border-top-width", + "border-right-width", + "border-bottom-width", + "border-left-width", + ]); + expect(got.changes.some(([p]) => p === "border-style")).toBe(false); + expect(got.changes.some(([p]) => p === "border-width")).toBe(false); + }); +}); diff --git a/packages/overlay/src/inspector/sections/stroke.ts b/packages/overlay/src/inspector/sections/stroke.ts index a6fc5b4..30ea8be 100644 --- a/packages/overlay/src/inspector/sections/stroke.ts +++ b/packages/overlay/src/inspector/sections/stroke.ts @@ -5,8 +5,10 @@ import { createTextField } from "../controls/num-field"; import { createQuadField } from "../controls/quad-field"; import { createSegmented } from "../controls/segmented"; import { createSelect } from "../controls/select"; +import { sameColor } from "../css-value"; import { STROKE_POSITION, STROKE_SIDES, STROKE_STYLE } from "../descriptors"; import { hasStroke } from "../gates"; +import { agreed } from "../mixed"; import { readValue } from "../style-model"; import type { SectionContext } from "./context"; @@ -37,6 +39,16 @@ import type { SectionContext } from "./context"; * A shorthand also cannot be taken back cleanly — `border-width: 0px` leaves the four * longhands in place and merely loses to them — which is why Remove looked like it had * worked while the quad field still read `8`. + * + * The first line was aspirational for a long time. Three writes still used the + * shorthand — the eye, the width field's implied `solid`, and the Style select — + * and the eye's was a live bug: `hasStroke` reads the longhands through + * `ctx.gate`, which does no shorthand expansion, so once *Add stroke* had + * written a pending `solid` on them the shorthand `none` could never win, and + * the eye did nothing. All three go through `writeAllEdges` now. + * + * The reads had the mirror-image problem and are fixed the same way: every one + * of them asked `border-top-*` and answered for the box. See `edgeValue`. */ const EDGES = ["top", "right", "bottom", "left"] as const; @@ -50,9 +62,42 @@ function writeAllEdges( } } +/** + * What all four edges say, or `MIXED` when they disagree. + * + * Every read in this section used to be `readValue(node, "border-top-*")` — the + * top edge speaking for the box. That is the same mistake the *writes* were + * fixed for: `.header { border-bottom: 1px solid #eee }` is the canonical + * divider, and this section showed it as an unstroked element with a black + * colour. Set three sides to red and the fourth to blue and the row claimed red + * for all four, then imposed it on the first edit. + * + * Colours compare through `sameColor`, not `===`. These four values do not all + * come from the same place once an edit is pending: `applyPreview` writes the + * picker's `rgb(r g b / a)` into the inline style of the edges just written, + * while the rest still read back the engine's legacy `rgb(r, g, b)`. String + * equality calls that a disagreement and shows `Mixed` on a box the user just + * made uniform. Note `panel.seed` compares with `===`, which is right for the + * keywords and lengths it handles and would be wrong here. + */ +function edgeValue( + node: Element, + suffix: "width" | "style" | "color", + fallback: string +): string { + return agreed( + EDGES.map((edge) => readValue(node, `border-${edge}-${suffix}`)), + fallback, + suffix === "color" ? (a, b) => sameColor(a, b, node) : undefined + ); +} + export function renderStroke(ctx: SectionContext, node: Element): HTMLElement { const body = el("div", { class: cls("sect-body") }); + /** The stroke's colour, or `MIXED`. Used as both the seed and the re-seed. */ + const strokeColor = (): string => edgeValue(node, "color", "#000000"); + // Colour writes the four longhands, not the `border-color` shorthand. // The widths beside it have always been longhands, so the shorthand was the // one declaration in this section that could not describe what the section @@ -71,7 +116,7 @@ export function renderStroke(ctx: SectionContext, node: Element): HTMLElement { rows.replaceChildren( el("div", { class: cls("rows-row") }, [ ctx.colorRow( - readValue(node, "border-top-color") || "#000000", + strokeColor(), "Stroke colour", (next) => { for (const side of STROKE_SIDES) { @@ -79,7 +124,22 @@ export function renderStroke(ctx: SectionContext, node: Element): HTMLElement { } }, node, - STROKE_SIDES.map((side) => `border-${side.name}-color`) + STROKE_SIDES.map((side) => `border-${side.name}-color`), + /* + * The sixth argument, and it is not optional here. + * + * Without it the re-seed pass pushes the raw per-property value + * (`panel.colorRow`'s `setValue`), and this row registers *four* + * properties — so it takes four `setValue` calls, one per edge, and + * `border-left-color` wins. A `Mixed` row would settle on the left + * edge's colour after the first undo, refresh or discard, which is + * the panel changing what it claims for no reason the user can see. + * + * The same expression as the seed, deliberately: `vector.ts` states + * the invariant — "the seed and the re-seed `read` have to agree on + * this" — and the only way to keep it is to have one function. + */ + strokeColor ), // The eye keeps the widths and drops the stroke out of what gets // painted — the same contract `row-list`'s disabled rows have. It @@ -92,7 +152,21 @@ export function renderStroke(ctx: SectionContext, node: Element): HTMLElement { class: cls("row-icon"), "data-tip": "Hide stroke", onClick: () => { - ctx.onChange("border-style", "none"); + /* + * Longhands, like everything else here — this wrote the + * `border-style` shorthand and was a no-op after the first + * *Add stroke*. + * + * `hasStroke` asks `ctx.gate` for each `border--style`, and + * the gate is `changeSet.snapshot(node, property)?.to ?? + * readValue(node, property)` — a per-property lookup with no + * shorthand expansion. Add writes the four longhands, so once a + * pending `solid` exists on them it shadows a pending `none` on + * the shorthand forever: the inline preview applied, + * `borderTopStyle` computed to `none`, and the section went on + * showing a stroke the element was not painting. + */ + writeAllEdges(ctx.onChange, "style", "none"); paintRows(); paintAdd(); }, @@ -136,11 +210,20 @@ export function renderStroke(ctx: SectionContext, node: Element): HTMLElement { // A border with no style is invisible however wide it is; setting one // implies the other, and leaving that to the user is a trap. onWrote: (_property, css) => { + /* + * All four edges, and longhands out. + * + * `edgeValue` returns `none` only when every edge agrees on it, so an + * element that already paints one edge is left alone — widening it + * should not silently draw the other three. The old + * `border-top-style === "none"` test asked one edge and then wrote the + * shorthand across all four, which is both halves of the same mistake. + */ if ( Number.parseFloat(css) > 0 && - readValue(node, "border-top-style") === "none" + edgeValue(node, "style", "none") === "none" ) { - ctx.onChange("border-style", "solid"); + writeAllEdges(ctx.onChange, "style", "solid"); paintRows(); paintAdd(); } @@ -208,9 +291,7 @@ export function renderStroke(ctx: SectionContext, node: Element): HTMLElement { const paintAdd = (): void => { const on = hasStroke(ctx.gate(node)); add.toggleAttribute("disabled", on); - add.dataset.tip = on - ? "An element has one CSS border. For a second ring, use an outline or a spread-only shadow" - : "Add stroke"; + add.dataset.tip = on ? "CSS gives an element one border" : "Add stroke"; }; paintAdd(); @@ -270,8 +351,7 @@ function openStrokeSettings( ); if (centre) { centre.toggleAttribute("disabled", true); - centre.dataset.tip = - "CSS borders sit inside or outside the box — there is no centre"; + centre.dataset.tip = "CSS has no centre border"; } body.append(popRow("Position", position.element)); @@ -281,10 +361,26 @@ function openStrokeSettings( * only solid and dash — so a segmented group would mix icon cells and text * pills, which is exactly the shape `segmented.ts` warns against. */ + /* + * Seeded from all four edges and writing all four, like the rest of the + * section. + * + * `STROKE_STYLE.cssProperty` is the `border-style` shorthand, so + * `createSelect` emits that — the third and last place this section wrote a + * declaration it could not read back. The `OnChange` is wrapped rather than + * the descriptor changed or `createSelect` taught a new trick: the select's + * job is to pick one of five keywords, and which properties that lands on is + * the section's business. + * + * A `MIXED` seed needs no handling here either. `createSelect` renders + * `options.find(o => o.value === current)?.label ?? current`, so it shows the + * word and marks nothing active — which is exactly right, and is why + * `panel.seed` made the sentinel a plain string. + */ const style = createSelect( STROKE_STYLE, - readValue(node, "border-top-style") || "none", - ctx.onChange + edgeValue(node, "style", "none"), + (_property, value) => writeAllEdges(ctx.onChange, "style", value) ); body.append(popRow("Style", style.element)); @@ -305,7 +401,7 @@ function openStrokeSettings( const field = createTextField({ glyph: label[0], label }); field.input.disabled = true; field.input.placeholder = "—"; - field.element.dataset.tip = `${label} length is chosen by the browser; CSS cannot set it`; + field.element.dataset.tip = `The browser picks the ${label.toLowerCase()} length`; dashes.append(field.element); } body.append(popRow("Dashes", dashes)); diff --git a/packages/overlay/src/stories/subjects.test.ts b/packages/overlay/src/stories/subjects.test.ts index 0efa92f..7b53843 100644 --- a/packages/overlay/src/stories/subjects.test.ts +++ b/packages/overlay/src/stories/subjects.test.ts @@ -49,6 +49,7 @@ describe("specimens", () => { "hero", "icon", "image", + "mixedBorder", "note", "paragraph", "path", diff --git a/packages/overlay/src/stories/subjects.ts b/packages/overlay/src/stories/subjects.ts index e393996..efd76e2 100644 --- a/packages/overlay/src/stories/subjects.ts +++ b/packages/overlay/src/stories/subjects.ts @@ -389,6 +389,23 @@ const SPECIMENS = { * more common shape in a real app, and it is the arm that would silently stop * working if the scan were dropped. */ + /** + * Four edges that disagree, which the Stroke section used to hide. + * + * Every read in that section asked `border-top-*` and answered for the whole + * box, so this element displayed as a uniform red 1px border — and the first + * edit imposed red on all four. Inline styles rather than a class, because + * what is under test is per-edge disagreement and a stylesheet rule would let + * a shorthand creep back in. + */ + mixedBorder: { + covers: + "four differing border colours and widths on one element · the Mixed sentinel on a hand-built colour row · hasStroke", + label: "a box with four different edges", + markup: `
Four edges, four colours.
`, + wrap: "block", + }, + note: { covers: "hasText via the text-node scan rather than the TEXTY tag set", label: "a note",