From 8b055a142335708b9fd70b43a9fd300eb5539da4 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 22:32:19 -0800 Subject: [PATCH 1/9] fix(ui): panel rails keep clear of an obstacle across the middle of the window An obstacle that crossed the middle of the window (the World Timeline, the voice control or a card in a window under about 520px tall) was neither above nor below it, so neither rail counted it and panels could be laid out over it. Such an obstacle now puts the panels on whichever side of it has more room. When neither side has room, the rails keep their existing minimum (the right rail's empty band, the left rail's minimum lane height). Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 6 ++++- src/cockpitMath.test.mjs | 52 +++++++++++++++++++++++++++++++++++++ src/ui/leftPanelRail.js | 20 ++++++++++++++ src/ui/panelRailGeometry.js | 14 +++++++++- src/ui/panelRails.test.mjs | 19 ++++++++++++++ 5 files changed, 109 insertions(+), 2 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 6b0cc95cdb..80e9f15833 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1197,7 +1197,11 @@ Cesium's credit box wraps from 1200px, as before; the phone shell, clean view, recording and scene playback lay the line out themselves. The left rail treats the centered World Timeline and voice control as obstacles only where they reach a laid-out panel, not the stack's -transparent gutter. +transparent gutter. Both rails keep clear of every obstacle they reach: one +above the middle of the window pushes the panels down, one below it pulls +them up, and one across the middle (common in short windows) puts them on +whichever side of it has more room. When neither side has room, the rails +keep their usual minimum height rather than overlap it. Wind appears in the Weather group before Audio. The surface-weather prototype uses keyless NOAA GFS or ECMWF IFS forecasts on an approximately 1° display grid. diff --git a/src/cockpitMath.test.mjs b/src/cockpitMath.test.mjs index 3892d510b0..ee9c8ad541 100644 --- a/src/cockpitMath.test.mjs +++ b/src/cockpitMath.test.mjs @@ -286,6 +286,58 @@ test('HUD rail layout constrains an oversized panel to the safe corridor', () => assert.equal(layout.constrained, true); }); +test('HUD rail layout keeps a short window clear of an obstacle across its midpoint', () => { + // 480px window: midpoint 240. Each obstacle is neither wholly above nor + // wholly below the midpoint, and must still limit the band. + const above = resolveHudRailLayout({ + viewportHeight: 480, + panelHeight: 120, + laneLeft: 20, + laneRight: 340, + baseTop: 40, + baseBottom: 460, + gap: 10, + obstacles: [{ left: 0, right: 400, top: 200, bottom: 300 }], + }); + // Room above: 200 - 10 - 40 = 150; below: 460 - 310 = 150. A tie keeps the + // band above the obstacle. + assert.equal(above.safeTop, 40); + assert.equal(above.safeBottom, 190); + assert(above.top + Math.min(120, above.maxHeight) <= 190); + + const below = resolveHudRailLayout({ + viewportHeight: 480, + panelHeight: 120, + laneLeft: 20, + laneRight: 340, + baseTop: 40, + baseBottom: 460, + gap: 10, + obstacles: [{ left: 0, right: 400, top: 120, bottom: 260 }], + }); + // Room above: 70; below: 190. The band goes under the obstacle. + assert.equal(below.safeTop, 270); + assert.equal(below.safeBottom, 460); + assert(below.top >= 270); +}); + +test('HUD rail layout keeps its zero-height fallback when a straddling obstacle leaves no room', () => { + const layout = resolveHudRailLayout({ + viewportHeight: 480, + panelHeight: 120, + laneLeft: 20, + laneRight: 340, + baseTop: 100, + baseBottom: 400, + gap: 10, + obstacles: [{ left: 0, right: 400, top: 80, bottom: 420 }], + }); + assert.equal(layout.maxHeight, 0); + assert.equal(layout.constrained, true); + assert.equal(layout.safeTop, 100); + assert.equal(layout.safeBottom, 100); +}); + test('HUD rail layout can anchor controls to the start of the safe corridor', () => { const layout = resolveHudRailLayout({ viewportHeight: 1000, diff --git a/src/ui/leftPanelRail.js b/src/ui/leftPanelRail.js index 2d3edda5e1..e19012c61f 100644 --- a/src/ui/leftPanelRail.js +++ b/src/ui/leftPanelRail.js @@ -118,6 +118,7 @@ export function layoutLeftPanelRail({ let safeTop = baseTop; let safeBottom = viewportHeight - baseBottomInset; const bottomObstacles = []; + const straddling = []; for (const obstacle of obstacles) { if (stack.contains(obstacle)) continue; @@ -153,8 +154,27 @@ export function layoutLeftPanelRail({ safeTop = Math.max(safeTop, obstacleBottom); } else if (rect.top >= baseTop) { bottomObstacles.push({ top: rect.top }); + } else { + straddling.push(rect); } } + // An obstacle from above the corridor across the midpoint (common in short + // windows) still limits it: the panels go on whichever side of it leaves + // more room. + for (const rect of straddling) { + const roomAbove = rect.top - safeGap - obstacleSafeTop; + const lowerBottom = resolveLeftStackBottomBoundary({ + baseBottom: safeBottom, + obstacles: bottomObstacles, + safeGap, + }); + const roomBelow = lowerBottom - (rect.bottom + safeGap); + if (roomBelow > roomAbove) { + const obstacleBottom = rect.bottom + safeGap; + obstacleSafeTop = Math.max(obstacleSafeTop, obstacleBottom); + safeTop = Math.max(safeTop, obstacleBottom); + } else bottomObstacles.push({ top: rect.top }); + } safeBottom = resolveLeftStackBottomBoundary({ baseBottom: safeBottom, obstacles: bottomObstacles, diff --git a/src/ui/panelRailGeometry.js b/src/ui/panelRailGeometry.js index 673f4871e7..fc973a638a 100644 --- a/src/ui/panelRailGeometry.js +++ b/src/ui/panelRailGeometry.js @@ -1,6 +1,8 @@ /** * Resolve a vertically centered panel slot inside a HUD rail while respecting - * live rectangles that intersect that rail above or below the viewport center. + * live rectangles that intersect that rail. A rectangle above the viewport + * center lowers the top, one below it raises the bottom, and one across the + * center does whichever leaves the band more room. */ export function resolveHudRailLayout({ viewportHeight, @@ -29,6 +31,7 @@ export function resolveHudRailLayout({ const midpoint = viewportHeight * 0.5; let safeTop = Math.max(0, baseTop); let safeBottom = Math.min(viewportHeight, baseBottom); + const straddling = []; for (const rect of obstacles) { if ( @@ -44,6 +47,15 @@ export function resolveHudRailLayout({ if (rect.bottom <= midpoint) safeTop = Math.max(safeTop, rect.bottom + gap); else if (rect.top >= midpoint) safeBottom = Math.min(safeBottom, rect.top - gap); + else straddling.push(rect); + } + // An obstacle across the midpoint (common in short windows) still limits + // the band: the band goes on whichever side of it leaves more room. + for (const rect of straddling) { + const roomAbove = rect.top - gap - safeTop; + const roomBelow = safeBottom - (rect.bottom + gap); + if (roomBelow > roomAbove) safeTop = Math.max(safeTop, rect.bottom + gap); + else safeBottom = Math.min(safeBottom, rect.top - gap); } safeBottom = Math.max(safeTop, safeBottom); diff --git a/src/ui/panelRails.test.mjs b/src/ui/panelRails.test.mjs index 416079aec7..32e52a8083 100644 --- a/src/ui/panelRails.test.mjs +++ b/src/ui/panelRails.test.mjs @@ -219,6 +219,25 @@ test('left corridor respects a lower obstacle but ignores an obstacle hidden by assert.equal(Number(f.stack.dataset.safeBottomPct), 65.47); }); +test('in a short window the left corridor stays clear of an obstacle across the midpoint', () => { + // 480px window, midpoint 240. Neither card is wholly above or below it. + const f = fixture('left'); + f.options.windowRef.innerHeight = 480; + const low = element('card', { top: 100, height: 200 }); + f.options.obstacles = [low]; + f.run(); + // More room below the card than above it: the corridor starts under it. + assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300); + assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 480); + + const high = element('card', { top: 200, height: 200 }); + f.options.obstacles = [high]; + f.run(); + // More room above it: the corridor ends over it. + assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 200); + assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 0); +}); + test('a centered timeline only shortens the corridor when it reaches a laid-out panel', () => { const f = fixture('left'); f.stack.rect.width = 360; From 31a7b6a0a536e50d7be141987fc61e691c05f6d8 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 22:32:50 -0800 Subject: [PATCH 2/9] Add the changelog entry for #1837 Co-authored-by: Manjunath Paparaju --- changelog.d/1837-rail-short-window.md | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 changelog.d/1837-rail-short-window.md diff --git a/changelog.d/1837-rail-short-window.md b/changelog.d/1837-rail-short-window.md new file mode 100644 index 0000000000..2eed1e44e2 --- /dev/null +++ b/changelog.d/1837-rail-short-window.md @@ -0,0 +1,3 @@ +- Keep the left and right panel rails clear of an obstacle across the middle + of a short window, such as the World Timeline or a card: the panels take + the side of it with more room (manjunath22466, samehkhamis, #1837). From feedd886141adb2e755eb9444b227190e6552aab Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 22:39:29 -0800 Subject: [PATCH 3/9] fix(ui): rails take obstacles across the middle together, so their order never picks the side Co-authored-by: Manjunath Paparaju --- changelog.d/1837-rail-short-window.md | 7 +++--- docs/CURRENT-STATE.md | 10 ++++---- src/cockpitMarkup.test.mjs | 2 +- src/cockpitMath.test.mjs | 28 ++++++++++++++++++--- src/ui/leftPanelRail.js | 36 ++++++++++++++++----------- src/ui/panelRailGeometry.js | 27 ++++++++++++-------- src/ui/panelRails.test.mjs | 34 +++++++++++++++++++------ 7 files changed, 99 insertions(+), 45 deletions(-) diff --git a/changelog.d/1837-rail-short-window.md b/changelog.d/1837-rail-short-window.md index 2eed1e44e2..5a6662ca1a 100644 --- a/changelog.d/1837-rail-short-window.md +++ b/changelog.d/1837-rail-short-window.md @@ -1,3 +1,4 @@ -- Keep the left and right panel rails clear of an obstacle across the middle - of a short window, such as the World Timeline or a card: the panels take - the side of it with more room (manjunath22466, samehkhamis, #1837). +- Keep the left and right panel rails clear of obstacles across the middle + of a short window, such as the World Timeline or a card: both rails put + the panels on the side with more room, whatever order the obstacles come + in (manjunath22466, samehkhamis, #1837). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 80e9f15833..5e36fa9df4 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1197,11 +1197,11 @@ Cesium's credit box wraps from 1200px, as before; the phone shell, clean view, recording and scene playback lay the line out themselves. The left rail treats the centered World Timeline and voice control as obstacles only where they reach a laid-out panel, not the stack's -transparent gutter. Both rails keep clear of every obstacle they reach: one -above the middle of the window pushes the panels down, one below it pulls -them up, and one across the middle (common in short windows) puts them on -whichever side of it has more room. When neither side has room, the rails -keep their usual minimum height rather than overlap it. +transparent gutter. Obstacles across the middle of the window (common in +short windows) are taken together, from the highest top to the lowest +bottom, and both rails put their panels on whichever side of that span has +more room, above it on a tie, whatever order the obstacles come in. With no +room on either side the panels keep their place, as before. Wind appears in the Weather group before Audio. The surface-weather prototype uses keyless NOAA GFS or ECMWF IFS forecasts on an approximately 1° display grid. diff --git a/src/cockpitMarkup.test.mjs b/src/cockpitMarkup.test.mjs index 3a084af32f..2fa3c1aea4 100644 --- a/src/cockpitMarkup.test.mjs +++ b/src/cockpitMarkup.test.mjs @@ -1010,7 +1010,7 @@ test('an expanded Cockpit left panel stays above Contact, HUD, and attribution', assert.ok(leftLayout, 'left accordion layout pass is missing'); assert.match( leftLayout, - /rect\.top >= baseTop\) \{\s*\n\s*bottomObstacles\.push\(\{ top: rect\.top \}\);/, + /\} else \{\s*\n\s*bottomObstacles\.push\(\{ top: rect\.top \}\);\s*\n\s*\}\s*\n\s*\}/, 'every rendered lower-lane obstacle must constrain the panel corridor', ); assert.match( diff --git a/src/cockpitMath.test.mjs b/src/cockpitMath.test.mjs index ee9c8ad541..8754954d66 100644 --- a/src/cockpitMath.test.mjs +++ b/src/cockpitMath.test.mjs @@ -321,7 +321,7 @@ test('HUD rail layout keeps a short window clear of an obstacle across its midpo assert(below.top >= 270); }); -test('HUD rail layout keeps its zero-height fallback when a straddling obstacle leaves no room', () => { +test('HUD rail layout leaves the band as it is when an obstacle across the midpoint leaves no room', () => { const layout = resolveHudRailLayout({ viewportHeight: 480, panelHeight: 120, @@ -332,10 +332,30 @@ test('HUD rail layout keeps its zero-height fallback when a straddling obstacle gap: 10, obstacles: [{ left: 0, right: 400, top: 80, bottom: 420 }], }); - assert.equal(layout.maxHeight, 0); - assert.equal(layout.constrained, true); assert.equal(layout.safeTop, 100); - assert.equal(layout.safeBottom, 100); + assert.equal(layout.safeBottom, 400); +}); + +test('HUD rail layout reads several obstacles across the midpoint the same in any order', () => { + const a = { left: 0, right: 400, top: 100, bottom: 260 }; + const b = { left: 0, right: 400, top: 200, bottom: 470 }; + const layoutWith = (obstacles) => + resolveHudRailLayout({ + viewportHeight: 480, + panelHeight: 120, + laneLeft: 20, + laneRight: 340, + baseTop: 40, + baseBottom: 460, + gap: 10, + obstacles, + }); + // Together they cover 100 to 470: the only room is above, 40 to 90. + for (const layout of [layoutWith([a, b]), layoutWith([b, a])]) { + assert.equal(layout.safeTop, 40); + assert.equal(layout.safeBottom, 90); + assert.equal(layout.maxHeight, 50); + } }); test('HUD rail layout can anchor controls to the start of the safe corridor', () => { diff --git a/src/ui/leftPanelRail.js b/src/ui/leftPanelRail.js index e19012c61f..909ed1b660 100644 --- a/src/ui/leftPanelRail.js +++ b/src/ui/leftPanelRail.js @@ -118,7 +118,10 @@ export function layoutLeftPanelRail({ let safeTop = baseTop; let safeBottom = viewportHeight - baseBottomInset; const bottomObstacles = []; - const straddling = []; + // Obstacles across the midpoint all cover it, so together they cover one + // span: from the highest top to the lowest bottom. + let spanTop = Infinity; + let spanBottom = -Infinity; for (const obstacle of obstacles) { if (stack.contains(obstacle)) continue; @@ -152,28 +155,31 @@ export function layoutLeftPanelRail({ const obstacleBottom = rect.bottom + safeGap; obstacleSafeTop = Math.max(obstacleSafeTop, obstacleBottom); safeTop = Math.max(safeTop, obstacleBottom); - } else if (rect.top >= baseTop) { - bottomObstacles.push({ top: rect.top }); + } else if ( + rect.top < viewportHeight * 0.5 && + rect.bottom > viewportHeight * 0.5 + ) { + spanTop = Math.min(spanTop, rect.top); + spanBottom = Math.max(spanBottom, rect.bottom); } else { - straddling.push(rect); + bottomObstacles.push({ top: rect.top }); } } - // An obstacle from above the corridor across the midpoint (common in short - // windows) still limits it: the panels go on whichever side of it leaves - // more room. - for (const rect of straddling) { - const roomAbove = rect.top - safeGap - obstacleSafeTop; + // The panels go on whichever side of that span leaves more room (common in + // short windows), above it on a tie. With no room on either side the + // corridor stays as it is. + if (spanBottom > spanTop) { + const roomAbove = spanTop - safeGap - obstacleSafeTop; const lowerBottom = resolveLeftStackBottomBoundary({ baseBottom: safeBottom, obstacles: bottomObstacles, safeGap, }); - const roomBelow = lowerBottom - (rect.bottom + safeGap); - if (roomBelow > roomAbove) { - const obstacleBottom = rect.bottom + safeGap; - obstacleSafeTop = Math.max(obstacleSafeTop, obstacleBottom); - safeTop = Math.max(safeTop, obstacleBottom); - } else bottomObstacles.push({ top: rect.top }); + const roomBelow = lowerBottom - (spanBottom + safeGap); + if (roomBelow > roomAbove && roomBelow > 0) { + obstacleSafeTop = Math.max(obstacleSafeTop, spanBottom + safeGap); + safeTop = Math.max(safeTop, spanBottom + safeGap); + } else if (roomAbove > 0) bottomObstacles.push({ top: spanTop }); } safeBottom = resolveLeftStackBottomBoundary({ baseBottom: safeBottom, diff --git a/src/ui/panelRailGeometry.js b/src/ui/panelRailGeometry.js index fc973a638a..65c53729c9 100644 --- a/src/ui/panelRailGeometry.js +++ b/src/ui/panelRailGeometry.js @@ -2,7 +2,8 @@ * Resolve a vertically centered panel slot inside a HUD rail while respecting * live rectangles that intersect that rail. A rectangle above the viewport * center lowers the top, one below it raises the bottom, and one across the - * center does whichever leaves the band more room. + * center puts the band on whichever side of it has more room, or leaves the + * band as it is when neither side has any. */ export function resolveHudRailLayout({ viewportHeight, @@ -31,7 +32,10 @@ export function resolveHudRailLayout({ const midpoint = viewportHeight * 0.5; let safeTop = Math.max(0, baseTop); let safeBottom = Math.min(viewportHeight, baseBottom); - const straddling = []; + // Every obstacle across the midpoint covers it, so together they cover one + // span: from the highest top to the lowest bottom. + let spanTop = Infinity; + let spanBottom = -Infinity; for (const rect of obstacles) { if ( @@ -47,15 +51,18 @@ export function resolveHudRailLayout({ if (rect.bottom <= midpoint) safeTop = Math.max(safeTop, rect.bottom + gap); else if (rect.top >= midpoint) safeBottom = Math.min(safeBottom, rect.top - gap); - else straddling.push(rect); + else { + spanTop = Math.min(spanTop, rect.top); + spanBottom = Math.max(spanBottom, rect.bottom); + } } - // An obstacle across the midpoint (common in short windows) still limits - // the band: the band goes on whichever side of it leaves more room. - for (const rect of straddling) { - const roomAbove = rect.top - gap - safeTop; - const roomBelow = safeBottom - (rect.bottom + gap); - if (roomBelow > roomAbove) safeTop = Math.max(safeTop, rect.bottom + gap); - else safeBottom = Math.min(safeBottom, rect.top - gap); + // The band goes on whichever side of that span leaves more room, above it + // on a tie. With no room on either side the band stays as it is. + if (spanBottom > spanTop) { + const roomAbove = spanTop - gap - safeTop; + const roomBelow = safeBottom - (spanBottom + gap); + if (roomBelow > roomAbove && roomBelow > 0) safeTop = spanBottom + gap; + else if (roomAbove > 0) safeBottom = spanTop - gap; } safeBottom = Math.max(safeTop, safeBottom); diff --git a/src/ui/panelRails.test.mjs b/src/ui/panelRails.test.mjs index 32e52a8083..e51de287fa 100644 --- a/src/ui/panelRails.test.mjs +++ b/src/ui/panelRails.test.mjs @@ -220,22 +220,42 @@ test('left corridor respects a lower obstacle but ignores an obstacle hidden by }); test('in a short window the left corridor stays clear of an obstacle across the midpoint', () => { - // 480px window, midpoint 240. Neither card is wholly above or below it. + // 480px window, midpoint 240. const f = fixture('left'); f.options.windowRef.innerHeight = 480; - const low = element('card', { top: 100, height: 200 }); - f.options.obstacles = [low]; + f.options.obstacles = [element('card', { top: 100, height: 200 })]; f.run(); // More room below the card than above it: the corridor starts under it. assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300); - assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 480); - const high = element('card', { top: 200, height: 200 }); - f.options.obstacles = [high]; + // A card starting below the corridor's usual top (26%, 124.8px) that + // crosses the midpoint counts the same way: more room below it. + f.options.obstacles = [element('card', { top: 130, height: 120 })]; f.run(); + assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 250); + // More room above it: the corridor ends over it. + f.options.obstacles = [element('card', { top: 200, height: 250 })]; + f.run(); assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 200); - assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 0); +}); + +test('several cards across the midpoint give the left corridor the same room in any order', () => { + const f = fixture('left'); + f.options.windowRef.innerHeight = 480; + const a = element('card', { top: 100, height: 160 }); + const b = element('card', { top: 110, height: 360 }); + f.options.obstacles = [a, b]; + f.run(); + const first = [f.stack.dataset.safeTopPct, f.stack.dataset.safeBottomPct]; + f.options.obstacles = [b, a]; + f.run(); + assert.deepEqual( + [f.stack.dataset.safeTopPct, f.stack.dataset.safeBottomPct], + first, + ); + // Together they cover 100 to 470: the corridor ends above them. + assert(Number(first[1]) * 4.8 <= 100); }); test('a centered timeline only shortens the corridor when it reaches a laid-out panel', () => { From 98a100ed7ebd5c13a65b56eec86f793e2bc65ba9 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 22:51:42 -0800 Subject: [PATCH 4/9] fix(ui): rails count the obstacles beside those across the middle, and read them as before when neither side has room Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 10 +++-- src/cockpitMarkup.test.mjs | 2 +- src/cockpitMath.test.mjs | 31 +++++++++++++ src/ui/leftPanelRail.js | 45 ++++++++----------- src/ui/panelRailGeometry.js | 88 +++++++++++++++++++++++++++++-------- src/ui/panelRails.test.mjs | 20 +++++++++ 6 files changed, 146 insertions(+), 50 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 5e36fa9df4..d08d3ccb0b 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1198,10 +1198,12 @@ view, recording and scene playback lay the line out themselves. The left rail treats the centered World Timeline and voice control as obstacles only where they reach a laid-out panel, not the stack's transparent gutter. Obstacles across the middle of the window (common in -short windows) are taken together, from the highest top to the lowest -bottom, and both rails put their panels on whichever side of that span has -more room, above it on a tie, whatever order the obstacles come in. With no -room on either side the panels keep their place, as before. +short windows) form one block with any obstacle that leaves no room between +itself and them, and both rails put their panels on whichever side of that +block has more room up to the next obstacle, above it on a tie, whatever +order the obstacles come in (`bandBesideMidpointObstacles` in +`src/ui/panelRailGeometry.js`). With no room on either side the obstacles +are read as before. Wind appears in the Weather group before Audio. The surface-weather prototype uses keyless NOAA GFS or ECMWF IFS forecasts on an approximately 1° display grid. diff --git a/src/cockpitMarkup.test.mjs b/src/cockpitMarkup.test.mjs index 2fa3c1aea4..3a084af32f 100644 --- a/src/cockpitMarkup.test.mjs +++ b/src/cockpitMarkup.test.mjs @@ -1010,7 +1010,7 @@ test('an expanded Cockpit left panel stays above Contact, HUD, and attribution', assert.ok(leftLayout, 'left accordion layout pass is missing'); assert.match( leftLayout, - /\} else \{\s*\n\s*bottomObstacles\.push\(\{ top: rect\.top \}\);\s*\n\s*\}\s*\n\s*\}/, + /rect\.top >= baseTop\) \{\s*\n\s*bottomObstacles\.push\(\{ top: rect\.top \}\);/, 'every rendered lower-lane obstacle must constrain the panel corridor', ); assert.match( diff --git a/src/cockpitMath.test.mjs b/src/cockpitMath.test.mjs index 8754954d66..d01a66209d 100644 --- a/src/cockpitMath.test.mjs +++ b/src/cockpitMath.test.mjs @@ -358,6 +358,37 @@ test('HUD rail layout reads several obstacles across the midpoint the same in an } }); +test('HUD rail layout counts obstacles beside those across the midpoint', () => { + const band = (obstacles) => { + const layout = resolveHudRailLayout({ + viewportHeight: 480, + panelHeight: 120, + laneLeft: 20, + laneRight: 340, + baseTop: 40, + baseBottom: 460, + gap: 10, + obstacles: obstacles.map(([top, bottom]) => ({ + left: 0, + right: 400, + top, + bottom, + })), + }); + return [layout.safeTop, layout.safeBottom]; + }; + // One inside the span below the midpoint: 150px below the span, 50 above. + assert.deepEqual(band([[100, 300], [250, 280]]), [310, 460]); + // One touching the midpoint from below: 190px below, 100 above. + assert.deepEqual(band([[150, 260], [240, 250]]), [270, 460]); + // One inside the span above the midpoint: 150px above, 50 below. + assert.deepEqual(band([[200, 400], [210, 230]]), [40, 190]); + // A lower obstacle past the span limits the room below it: 100px between + // them against 70 above, and with a taller one only 60, so above. + assert.deepEqual(band([[120, 260], [380, 420]]), [270, 370]); + assert.deepEqual(band([[120, 260], [340, 420]]), [40, 110]); +}); + test('HUD rail layout can anchor controls to the start of the safe corridor', () => { const layout = resolveHudRailLayout({ viewportHeight: 1000, diff --git a/src/ui/leftPanelRail.js b/src/ui/leftPanelRail.js index 909ed1b660..c6e7f6d1f3 100644 --- a/src/ui/leftPanelRail.js +++ b/src/ui/leftPanelRail.js @@ -5,6 +5,7 @@ import { resolvePanelStackCorridor, } from '../panelStackLayout.js'; import { measurePanelNaturalHeight } from './panelMeasurement.js'; +import { bandBesideMidpointObstacles } from './panelRailGeometry.js'; import { settleSideAccordion } from './panelAccordion.js'; /** @@ -118,10 +119,7 @@ export function layoutLeftPanelRail({ let safeTop = baseTop; let safeBottom = viewportHeight - baseBottomInset; const bottomObstacles = []; - // Obstacles across the midpoint all cover it, so together they cover one - // span: from the highest top to the lowest bottom. - let spanTop = Infinity; - let spanBottom = -Infinity; + const inLane = []; for (const obstacle of obstacles) { if (stack.contains(obstacle)) continue; @@ -151,35 +149,30 @@ export function layoutLeftPanelRail({ ); if (!overlapsHorizontally) continue; + inLane.push(rect); if (rect.top < baseTop && rect.bottom <= viewportHeight * 0.5) { const obstacleBottom = rect.bottom + safeGap; obstacleSafeTop = Math.max(obstacleSafeTop, obstacleBottom); safeTop = Math.max(safeTop, obstacleBottom); - } else if ( - rect.top < viewportHeight * 0.5 && - rect.bottom > viewportHeight * 0.5 - ) { - spanTop = Math.min(spanTop, rect.top); - spanBottom = Math.max(spanBottom, rect.bottom); - } else { + } else if (rect.top >= baseTop) { bottomObstacles.push({ top: rect.top }); } } - // The panels go on whichever side of that span leaves more room (common in - // short windows), above it on a tie. With no room on either side the - // corridor stays as it is. - if (spanBottom > spanTop) { - const roomAbove = spanTop - safeGap - obstacleSafeTop; - const lowerBottom = resolveLeftStackBottomBoundary({ - baseBottom: safeBottom, - obstacles: bottomObstacles, - safeGap, - }); - const roomBelow = lowerBottom - (spanBottom + safeGap); - if (roomBelow > roomAbove && roomBelow > 0) { - obstacleSafeTop = Math.max(obstacleSafeTop, spanBottom + safeGap); - safeTop = Math.max(safeTop, spanBottom + safeGap); - } else if (roomAbove > 0) bottomObstacles.push({ top: spanTop }); + // Obstacles across the midpoint (common in short windows) put the panels + // on whichever side of them has more room; with no room on either side the + // obstacles are read as before. + const beside = bandBesideMidpointObstacles({ + midpoint: viewportHeight * 0.5, + top: viewportHeight * 0.04, + bottom: safeBottom, + obstacles: inLane, + gap: safeGap, + }); + if (beside) { + obstacleSafeTop = beside.top; + safeTop = Math.max(baseTop, beside.top); + bottomObstacles.length = 0; + bottomObstacles.push({ top: beside.bottom + safeGap }); } safeBottom = resolveLeftStackBottomBoundary({ baseBottom: safeBottom, diff --git a/src/ui/panelRailGeometry.js b/src/ui/panelRailGeometry.js index 65c53729c9..1d0821534f 100644 --- a/src/ui/panelRailGeometry.js +++ b/src/ui/panelRailGeometry.js @@ -1,9 +1,9 @@ /** * Resolve a vertically centered panel slot inside a HUD rail while respecting * live rectangles that intersect that rail. A rectangle above the viewport - * center lowers the top, one below it raises the bottom, and one across the - * center puts the band on whichever side of it has more room, or leaves the - * band as it is when neither side has any. + * center lowers the top and one below it raises the bottom. Rectangles across + * the center put the band beside them (bandBesideMidpointObstacles); with no + * room on either side they are left out, as before. */ export function resolveHudRailLayout({ viewportHeight, @@ -32,10 +32,7 @@ export function resolveHudRailLayout({ const midpoint = viewportHeight * 0.5; let safeTop = Math.max(0, baseTop); let safeBottom = Math.min(viewportHeight, baseBottom); - // Every obstacle across the midpoint covers it, so together they cover one - // span: from the highest top to the lowest bottom. - let spanTop = Infinity; - let spanBottom = -Infinity; + const inLane = []; for (const rect of obstacles) { if ( @@ -48,22 +45,19 @@ export function resolveHudRailLayout({ rect.bottom <= rect.top ) continue; + inLane.push(rect); if (rect.bottom <= midpoint) safeTop = Math.max(safeTop, rect.bottom + gap); else if (rect.top >= midpoint) safeBottom = Math.min(safeBottom, rect.top - gap); - else { - spanTop = Math.min(spanTop, rect.top); - spanBottom = Math.max(spanBottom, rect.bottom); - } - } - // The band goes on whichever side of that span leaves more room, above it - // on a tie. With no room on either side the band stays as it is. - if (spanBottom > spanTop) { - const roomAbove = spanTop - gap - safeTop; - const roomBelow = safeBottom - (spanBottom + gap); - if (roomBelow > roomAbove && roomBelow > 0) safeTop = spanBottom + gap; - else if (roomAbove > 0) safeBottom = spanTop - gap; } + const beside = bandBesideMidpointObstacles({ + midpoint, + top: Math.max(0, baseTop), + bottom: Math.min(viewportHeight, baseBottom), + obstacles: inLane, + gap, + }); + if (beside) ({ top: safeTop, bottom: safeBottom } = beside); safeBottom = Math.max(safeTop, safeBottom); const availableHeight = Math.max(0, safeBottom - safeTop); @@ -80,6 +74,62 @@ export function resolveHudRailLayout({ }; } +/** + * Where a rail's band goes when obstacles cross the viewport midpoint, as in + * short windows. Those obstacles, and any other that leaves no band between + * itself and them, form one block; the band takes whichever side of the block + * has more room between it and the next obstacle or the band's own edge, + * above on a tie. + * @param {object} input + * @param {number} input.midpoint The viewport's vertical midpoint. + * @param {number} input.top The band's highest top. + * @param {number} input.bottom The band's lowest bottom. + * @param {Array<{top: number, bottom: number}>} input.obstacles Rectangles that reach the rail. + * @param {number} input.gap Space kept between the band and an obstacle. + * @returns {{side: 'above' | 'below', top: number, bottom: number} | null} + * Null when nothing crosses the midpoint or neither side has room. + */ +export function bandBesideMidpointObstacles({ + midpoint, + top, + bottom, + obstacles, + gap, +}) { + const crossing = obstacles.filter( + (rect) => rect.top < midpoint && rect.bottom > midpoint, + ); + if (!crossing.length) return null; + let blockTop = Math.min(...crossing.map((rect) => rect.top)); + let blockBottom = Math.max(...crossing.map((rect) => rect.bottom)); + for (let grown = true; grown;) { + grown = false; + for (const rect of obstacles) { + const touches = + rect.top < blockBottom + 2 * gap && rect.bottom > blockTop - 2 * gap; + if (touches && (rect.top < blockTop || rect.bottom > blockBottom)) { + blockTop = Math.min(blockTop, rect.top); + blockBottom = Math.max(blockBottom, rect.bottom); + grown = true; + } + } + } + let aboveTop = top; + let belowBottom = bottom; + for (const rect of obstacles) { + if (rect.bottom <= blockTop) + aboveTop = Math.max(aboveTop, rect.bottom + gap); + else if (rect.top >= blockBottom) + belowBottom = Math.min(belowBottom, rect.top - gap); + } + const above = { side: 'above', top: aboveTop, bottom: blockTop - gap }; + const below = { side: 'below', top: blockBottom + gap, bottom: belowBottom }; + const roomAbove = above.bottom - above.top; + const roomBelow = below.bottom - below.top; + if (roomBelow > roomAbove && roomBelow > 0) return below; + return roomAbove > 0 ? above : null; +} + /** * Whether the Tactical layout hid collapsed right panels beside an expanded * one. The rail now enforces one open panel per side in every layout; this diff --git a/src/ui/panelRails.test.mjs b/src/ui/panelRails.test.mjs index e51de287fa..c58d7b0603 100644 --- a/src/ui/panelRails.test.mjs +++ b/src/ui/panelRails.test.mjs @@ -258,6 +258,26 @@ test('several cards across the midpoint give the left corridor the same room in assert(Number(first[1]) * 4.8 <= 100); }); +test('the left corridor counts cards beside those across the midpoint', () => { + const f = fixture('left'); + f.options.windowRef.innerHeight = 480; + // A card inside the span below the midpoint: more room below both. + f.options.obstacles = [ + element('card', { top: 100, height: 200 }), + element('card', { top: 250, height: 30 }), + ]; + f.run(); + assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300); + // No room on either side: the cards are read as before, and the corridor + // never runs down through the lower one. + f.options.obstacles = [ + element('card', { top: 50, height: 150 }), + element('card', { top: 150, height: 320 }), + ]; + f.run(); + assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 210); +}); + test('a centered timeline only shortens the corridor when it reaches a laid-out panel', () => { const f = fixture('left'); f.stack.rect.width = 360; From 81df2c8c42bad49216bf7f1627f96fdd6d63de9d Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 23:01:47 -0800 Subject: [PATCH 5/9] fix(ui): the left rail's panels use all the room it counted above an obstacle across the middle Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 5 +++-- src/ui/leftPanelRail.js | 10 ++++++---- src/ui/panelRails.test.mjs | 19 ++++++++++++++++--- 3 files changed, 25 insertions(+), 9 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index d08d3ccb0b..91655cb712 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1202,8 +1202,9 @@ short windows) form one block with any obstacle that leaves no room between itself and them, and both rails put their panels on whichever side of that block has more room up to the next obstacle, above it on a tie, whatever order the obstacles come in (`bandBesideMidpointObstacles` in -`src/ui/panelRailGeometry.js`). With no room on either side the obstacles -are read as before. +`src/ui/panelRailGeometry.js`); on the left rail the panels may then rise +above the corridor's usual top to use all the room above. With no room on +either side the obstacles are read as before. Wind appears in the Weather group before Audio. The surface-weather prototype uses keyless NOAA GFS or ECMWF IFS forecasts on an approximately 1° display grid. diff --git a/src/ui/leftPanelRail.js b/src/ui/leftPanelRail.js index c6e7f6d1f3..4def1dcfc6 100644 --- a/src/ui/leftPanelRail.js +++ b/src/ui/leftPanelRail.js @@ -115,7 +115,8 @@ export function layoutLeftPanelRail({ const baseTop = viewportHeight * 0.26; const baseBottomInset = viewportHeight * 0.04; const safeGap = viewportHeight * 0.012; - let obstacleSafeTop = viewportHeight * 0.04; + const topInset = viewportHeight * 0.04; + let obstacleSafeTop = topInset; let safeTop = baseTop; let safeBottom = viewportHeight - baseBottomInset; const bottomObstacles = []; @@ -159,18 +160,19 @@ export function layoutLeftPanelRail({ } } // Obstacles across the midpoint (common in short windows) put the panels - // on whichever side of them has more room; with no room on either side the + // on whichever side of them has more room, and the panels may use all of + // it, above the corridor's usual top too; with no room on either side the // obstacles are read as before. const beside = bandBesideMidpointObstacles({ midpoint: viewportHeight * 0.5, - top: viewportHeight * 0.04, + top: topInset, bottom: safeBottom, obstacles: inLane, gap: safeGap, }); if (beside) { obstacleSafeTop = beside.top; - safeTop = Math.max(baseTop, beside.top); + safeTop = beside.top; bottomObstacles.length = 0; bottomObstacles.push({ top: beside.bottom + safeGap }); } diff --git a/src/ui/panelRails.test.mjs b/src/ui/panelRails.test.mjs index c58d7b0603..32f972775c 100644 --- a/src/ui/panelRails.test.mjs +++ b/src/ui/panelRails.test.mjs @@ -268,14 +268,27 @@ test('the left corridor counts cards beside those across the midpoint', () => { ]; f.run(); assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300); - // No room on either side: the cards are read as before, and the corridor - // never runs down through the lower one. + // Only a little room above the cards: the corridor stays there rather + // than run down through the lower one. f.options.obstacles = [ element('card', { top: 50, height: 150 }), element('card', { top: 150, height: 320 }), ]; f.run(); - assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 210); + assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 50); + // The room above a card is all the panels' to use, above the corridor's + // usual top (26%) too: 700px window, card 300 to 420, about 263px above + // against 244 below. + f.options.windowRef.innerHeight = 700; + f.options.obstacles = [element('card', { top: 300, height: 120 })]; + f.run(); + assert(Number(f.stack.dataset.safeBottomPct) * 7 <= 300); + assert(Number(f.stack.dataset.safeTopPct) * 7 < 0.26 * 700); + // No room on either side: the card is read as before. + f.options.windowRef.innerHeight = 480; + f.options.obstacles = [element('card', { top: 0, height: 480 })]; + f.run(); + assert.equal(Number(f.stack.dataset.safeTopPct), 26); }); test('a centered timeline only shortens the corridor when it reaches a laid-out panel', () => { From 378df7b6136cc9ccdbb8f324f88ca7254ed6c01d Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 23:02:10 -0800 Subject: [PATCH 6/9] fix(ui): neighbours exactly two gaps from a midpoint obstacle join its block, and the band beside it stays inside the rail's own edges Co-authored-by: Manjunath Paparaju --- src/cockpitMath.test.mjs | 18 ++++++++++++++++++ src/ui/panelRailGeometry.js | 14 +++++++++++--- src/ui/panelRails.test.mjs | 2 +- 3 files changed, 30 insertions(+), 4 deletions(-) diff --git a/src/cockpitMath.test.mjs b/src/cockpitMath.test.mjs index d01a66209d..cda54d2c6a 100644 --- a/src/cockpitMath.test.mjs +++ b/src/cockpitMath.test.mjs @@ -387,6 +387,24 @@ test('HUD rail layout counts obstacles beside those across the midpoint', () => // them against 70 above, and with a taller one only 60, so above. assert.deepEqual(band([[120, 260], [380, 420]]), [270, 370]); assert.deepEqual(band([[120, 260], [340, 420]]), [40, 110]); + // Neighbours exactly two gaps away leave no room between: one block, 100 + // to 400, and a tie (50px a side) goes above. + assert.deepEqual(band([[100, 180], [200, 300], [320, 400]]), [40, 90]); +}); + +test('HUD rail layout keeps a band beside a midpoint obstacle inside its own edges', () => { + const layout = resolveHudRailLayout({ + viewportHeight: 480, + panelHeight: 80, + laneLeft: 20, + laneRight: 340, + baseTop: 350, + baseBottom: 460, + gap: 10, + obstacles: [{ left: 0, right: 400, top: 100, bottom: 260 }], + }); + assert.equal(layout.safeTop, 350); + assert.equal(layout.safeBottom, 460); }); test('HUD rail layout can anchor controls to the start of the safe corridor', () => { diff --git a/src/ui/panelRailGeometry.js b/src/ui/panelRailGeometry.js index 1d0821534f..b845a1a5c5 100644 --- a/src/ui/panelRailGeometry.js +++ b/src/ui/panelRailGeometry.js @@ -106,7 +106,7 @@ export function bandBesideMidpointObstacles({ grown = false; for (const rect of obstacles) { const touches = - rect.top < blockBottom + 2 * gap && rect.bottom > blockTop - 2 * gap; + rect.top <= blockBottom + 2 * gap && rect.bottom >= blockTop - 2 * gap; if (touches && (rect.top < blockTop || rect.bottom > blockBottom)) { blockTop = Math.min(blockTop, rect.top); blockBottom = Math.max(blockBottom, rect.bottom); @@ -122,8 +122,16 @@ export function bandBesideMidpointObstacles({ else if (rect.top >= blockBottom) belowBottom = Math.min(belowBottom, rect.top - gap); } - const above = { side: 'above', top: aboveTop, bottom: blockTop - gap }; - const below = { side: 'below', top: blockBottom + gap, bottom: belowBottom }; + const above = { + side: 'above', + top: aboveTop, + bottom: Math.min(bottom, blockTop - gap), + }; + const below = { + side: 'below', + top: Math.max(top, blockBottom + gap), + bottom: belowBottom, + }; const roomAbove = above.bottom - above.top; const roomBelow = below.bottom - below.top; if (roomBelow > roomAbove && roomBelow > 0) return below; diff --git a/src/ui/panelRails.test.mjs b/src/ui/panelRails.test.mjs index 32f972775c..1b67600b88 100644 --- a/src/ui/panelRails.test.mjs +++ b/src/ui/panelRails.test.mjs @@ -283,7 +283,7 @@ test('the left corridor counts cards beside those across the midpoint', () => { f.options.obstacles = [element('card', { top: 300, height: 120 })]; f.run(); assert(Number(f.stack.dataset.safeBottomPct) * 7 <= 300); - assert(Number(f.stack.dataset.safeTopPct) * 7 < 0.26 * 700); + assert(Number(f.stack.dataset.safeTopPct) * 7 <= 30); // No room on either side: the card is read as before. f.options.windowRef.innerHeight = 480; f.options.obstacles = [element('card', { top: 0, height: 480 })]; From 10dbd2f937b77e349c2d96707775dd0d69bf5780 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 23:14:26 -0800 Subject: [PATCH 7/9] fix(ui): a side of a midpoint block thinner than 8% of the window holds no panel; pin the lower merge edge Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 3 ++- src/cockpitMath.test.mjs | 6 ++++++ src/ui/leftPanelRail.js | 2 ++ src/ui/panelRailGeometry.js | 10 ++++++++-- src/ui/panelRails.test.mjs | 7 ++++--- 5 files changed, 22 insertions(+), 6 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 91655cb712..6cd948e474 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1204,7 +1204,8 @@ block has more room up to the next obstacle, above it on a tie, whatever order the obstacles come in (`bandBesideMidpointObstacles` in `src/ui/panelRailGeometry.js`); on the left rail the panels may then rise above the corridor's usual top to use all the room above. With no room on -either side the obstacles are read as before. +either side (a side under 8% of the window's height counts as none) the +obstacles are read as before. Wind appears in the Weather group before Audio. The surface-weather prototype uses keyless NOAA GFS or ECMWF IFS forecasts on an approximately 1° display grid. diff --git a/src/cockpitMath.test.mjs b/src/cockpitMath.test.mjs index cda54d2c6a..dd4d55a689 100644 --- a/src/cockpitMath.test.mjs +++ b/src/cockpitMath.test.mjs @@ -390,6 +390,12 @@ test('HUD rail layout counts obstacles beside those across the midpoint', () => // Neighbours exactly two gaps away leave no room between: one block, 100 // to 400, and a tie (50px a side) goes above. assert.deepEqual(band([[100, 180], [200, 300], [320, 400]]), [40, 90]); + // A neighbour exactly two gaps below joins it too: 150 to 300, 110px + // above against 150 below. + assert.deepEqual(band([[150, 250], [270, 300]]), [310, 460]); + // A side under 8% of the window (38.4px) is no room: 30px above, none + // below, so the band stays as it is. + assert.deepEqual(band([[80, 455]]), [40, 460]); }); test('HUD rail layout keeps a band beside a midpoint obstacle inside its own edges', () => { diff --git a/src/ui/leftPanelRail.js b/src/ui/leftPanelRail.js index 4def1dcfc6..5b6af7be0f 100644 --- a/src/ui/leftPanelRail.js +++ b/src/ui/leftPanelRail.js @@ -169,6 +169,8 @@ export function layoutLeftPanelRail({ bottom: safeBottom, obstacles: inLane, gap: safeGap, + // A side thinner than this holds no usable panel. + minimum: viewportHeight * 0.08, }); if (beside) { obstacleSafeTop = beside.top; diff --git a/src/ui/panelRailGeometry.js b/src/ui/panelRailGeometry.js index b845a1a5c5..c7266d8c72 100644 --- a/src/ui/panelRailGeometry.js +++ b/src/ui/panelRailGeometry.js @@ -56,6 +56,8 @@ export function resolveHudRailLayout({ bottom: Math.min(viewportHeight, baseBottom), obstacles: inLane, gap, + // A side thinner than this holds no usable panel. + minimum: viewportHeight * 0.08, }); if (beside) ({ top: safeTop, bottom: safeBottom } = beside); @@ -86,6 +88,8 @@ export function resolveHudRailLayout({ * @param {number} input.bottom The band's lowest bottom. * @param {Array<{top: number, bottom: number}>} input.obstacles Rectangles that reach the rail. * @param {number} input.gap Space kept between the band and an obstacle. + * @param {number} [input.minimum=0] The least room a side needs to count; + * a thinner side is no room at all. * @returns {{side: 'above' | 'below', top: number, bottom: number} | null} * Null when nothing crosses the midpoint or neither side has room. */ @@ -95,6 +99,7 @@ export function bandBesideMidpointObstacles({ bottom, obstacles, gap, + minimum = 0, }) { const crossing = obstacles.filter( (rect) => rect.top < midpoint && rect.bottom > midpoint, @@ -134,8 +139,9 @@ export function bandBesideMidpointObstacles({ }; const roomAbove = above.bottom - above.top; const roomBelow = below.bottom - below.top; - if (roomBelow > roomAbove && roomBelow > 0) return below; - return roomAbove > 0 ? above : null; + const least = Math.max(minimum, Number.EPSILON); + if (roomBelow > roomAbove && roomBelow >= least) return below; + return roomAbove >= least ? above : null; } /** diff --git a/src/ui/panelRails.test.mjs b/src/ui/panelRails.test.mjs index 1b67600b88..d4a67ed523 100644 --- a/src/ui/panelRails.test.mjs +++ b/src/ui/panelRails.test.mjs @@ -268,14 +268,15 @@ test('the left corridor counts cards beside those across the midpoint', () => { ]; f.run(); assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300); - // Only a little room above the cards: the corridor stays there rather - // than run down through the lower one. + // About 25px above the cards is under the least usable room (8% of the + // window): they are read as before, the upper card pushing the corridor + // down past it rather than into a sliver at the top. f.options.obstacles = [ element('card', { top: 50, height: 150 }), element('card', { top: 150, height: 320 }), ]; f.run(); - assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 50); + assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 200); // The room above a card is all the panels' to use, above the corridor's // usual top (26%) too: 700px window, card 300 to 420, about 263px above // against 244 below. From fd64a78aca68f1e2faa1ebac302761478db1f265 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 23:26:10 -0800 Subject: [PATCH 8/9] test(ui): pin the midpoint band's exact minimum, and correct a test comment Co-authored-by: Manjunath Paparaju --- src/cockpitMath.test.mjs | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/cockpitMath.test.mjs b/src/cockpitMath.test.mjs index dd4d55a689..3f8d396211 100644 --- a/src/cockpitMath.test.mjs +++ b/src/cockpitMath.test.mjs @@ -31,6 +31,7 @@ import { speedRulerStep, speedRulerTicks, } from './cockpitMath.js'; +import { bandBesideMidpointObstacles } from './ui/panelRailGeometry.js'; test('cockpit presentation updates are throttled independently of camera frames', () => { assert.equal(cockpitUiUpdateDue(1000, 0, 100), true); @@ -390,12 +391,22 @@ test('HUD rail layout counts obstacles beside those across the midpoint', () => // Neighbours exactly two gaps away leave no room between: one block, 100 // to 400, and a tie (50px a side) goes above. assert.deepEqual(band([[100, 180], [200, 300], [320, 400]]), [40, 90]); - // A neighbour exactly two gaps below joins it too: 150 to 300, 110px + // A neighbour exactly two gaps below joins it too: 150 to 300, 100px // above against 150 below. assert.deepEqual(band([[150, 250], [270, 300]]), [310, 460]); // A side under 8% of the window (38.4px) is no room: 30px above, none // below, so the band stays as it is. assert.deepEqual(band([[80, 455]]), [40, 460]); + // Exactly the minimum is enough. + const exact = bandBesideMidpointObstacles({ + midpoint: 240, + top: 40, + bottom: 460, + obstacles: [{ top: 90, bottom: 465 }], + gap: 10, + minimum: 40, + }); + assert.deepEqual([exact?.top, exact?.bottom], [40, 80]); }); test('HUD rail layout keeps a band beside a midpoint obstacle inside its own edges', () => { From c1e58b72b90cb99bfef069849aae11e1a890cf54 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 23:26:22 -0800 Subject: [PATCH 9/9] fix(ui): any positive room counts when a midpoint band asks for no minimum Co-authored-by: Manjunath Paparaju --- src/ui/panelRailGeometry.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ui/panelRailGeometry.js b/src/ui/panelRailGeometry.js index c7266d8c72..0cc2f0db25 100644 --- a/src/ui/panelRailGeometry.js +++ b/src/ui/panelRailGeometry.js @@ -139,9 +139,9 @@ export function bandBesideMidpointObstacles({ }; const roomAbove = above.bottom - above.top; const roomBelow = below.bottom - below.top; - const least = Math.max(minimum, Number.EPSILON); - if (roomBelow > roomAbove && roomBelow >= least) return below; - return roomAbove >= least ? above : null; + const fits = (room) => room > 0 && room >= minimum; + if (roomBelow > roomAbove && fits(roomBelow)) return below; + return fits(roomAbove) ? above : null; } /**