fix(deps): update material3 (alpha) to v1.5.0-alpha28

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimelineZoom.kt

@@ -19,6 +19,7 @@ import androidx.compose.ui.input.pointer.PointerEventPass
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.unit.Dp
 import kotlin.math.abs
+import kotlin.math.ceil
 import kotlin.math.floor
 import kotlin.math.roundToInt
 
@@ -196,26 +197,18 @@ fun rememberTimelinePinchZoom(
  * names, jumping the whole column as a pinch drifts across each half pixel.
  * Pinning the hour to whole pixels keeps every part of the timeline on one grid.
  *
- * The ceiling is pulled onto that grid too, downwards, so it stays a height the
- * pinch can actually land on.
- *
- * [fillPx] is deliberately *not* rounded (#290). It is the one height the whole
- * day exactly fills the viewport at, and it is the same value
- * [TimelineScale.FitDay] resolves to — rounding it up by the fraction of a pixel
- * that 24 hours don't divide the viewport into leaves the timeline a pixel per
- * hour taller than its own viewport, so a pinched-all-the-way-out day still
- * scrolls a hair and bounces off Android's overscroll stretch, while the
- * identical FitDay preset sits still. Being the clamp result rather than a bound
- * the gesture is merely held against, it is a height the pinch does land on: the
- * next frame reads it back unchanged and the focal anchor is handed nothing to
- * correct.
+ * The bounds themselves are pulled onto that grid too, each in the direction
+ * that keeps its own promise — up for the fill floor, so no dead space opens
+ * under midnight, down for the ceiling. A fractional bound would be a height the
+ * pinch can be held against but never actually land on, and the difference feeds
+ * the focal anchor a scroll correction on every frame the fingers sit still.
  */
 internal fun pinchedHourHeightPx(target: Float, fillPx: Float, maxPx: Float): Float =
     // Filling the viewport wins over the ceiling: on a screen tall enough for
     // the two to disagree, dead space is the worse of the two failures.
     target.roundToInt().toFloat()
         .coerceAtMost(floor(maxPx))
-        .coerceAtLeast(fillPx)
+        .coerceAtLeast(ceil(fillPx))
 
 /**
  * The scroll offset that keeps the moment under [centroidY] under it after the

app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthChipGeometry.kt

@@ -10,16 +10,10 @@ import androidx.compose.ui.unit.dp
 internal val CELL_GAP = 2.dp
 
 /** Padding between a month chip's edge and its text. */
-internal val MONTH_CHIP_TEXT_PADDING = 3.dp
+internal val MONTH_CHIP_TEXT_PADDING = 4.dp
 
-/**
- * A chip's own inset inside its day cell. The cell's gap and no more: a day
- * column on a phone is around fifty dp, and the chip was spending a quarter of
- * it on chrome before a single glyph. The cells keep their full separation from
- * each other — what the grid reads as breathing room — and only the chip inside
- * one takes the width back (#212).
- */
-internal val MONTH_CHIP_INSET = CELL_GAP
+/** A chip's own inset inside its day cell, on top of the cell's gap. */
+internal val MONTH_CHIP_INSET = CELL_GAP + 1.dp
 
 /** Horizontal space a chip spends on chrome rather than on text, both sides. */
 internal val MONTH_CHIP_CHROME = (MONTH_CHIP_INSET + MONTH_CHIP_TEXT_PADDING) * 2f

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/TimelineZoomTest.kt

@@ -1,6 +1,5 @@
 package de.jeanlucmakiola.calendula.ui.common
 
-import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.dp
 import com.google.common.truth.Truth.assertThat
 import org.junit.jupiter.api.Test
@@ -76,16 +75,17 @@ class TimelineZoomTest {
     }
 
     @Test
-    fun `a pinch held against either bound stays put`() {
+    fun `a pinch held against a fractional bound stays put`() {
+        // A bound that is not a whole pixel is a height the pinch can be pushed
+        // against but never land on, so every frame of a held gesture would look
+        // like a scale change and hand the focal anchor a scroll correction.
         val fillPx = 62.083f
         val maxPx = 616.5f
 
         val floor = pinchedHourHeightPx(target = 1f, fillPx, maxPx)
         val ceiling = pinchedHourHeightPx(target = 9_000f, fillPx, maxPx)
 
-        // The ceiling is pulled onto the pixel grid so it stays landable; the
-        // fill floor is landable as it is, being the clamp result itself.
-        assertThat(floor).isEqualTo(fillPx)
+        assertThat(floor).isEqualTo(63f)
         assertThat(ceiling).isEqualTo(616f)
         // Landing there and being pushed further must not move them again.
         assertThat(pinchedHourHeightPx(floor * 0.9f, fillPx, maxPx)).isEqualTo(floor)
@@ -100,35 +100,6 @@ class TimelineZoomTest {
         assertThat(floor * 24).isAtLeast(viewport)
     }
 
-    @Test
-    fun `pinching all the way out leaves nothing to scroll`() {
-        // #290: rounding the fill floor up to a whole pixel made the day one
-        // pixel per hour taller than the viewport it was supposed to fill, so a
-        // fully zoomed-out timeline still scrolled a hair and bounced off
-        // Android's overscroll stretch -- while FitDay, at the same zoom, sat
-        // still. 1490 is deliberately not divisible by 24.
-        val viewport = 1490f
-        val floor = pinchedHourHeightPx(target = 1f, fillPx = viewport / 24f, maxPx = 616f)
-        assertThat(floor * 24).isWithin(0.01f).of(viewport)
-    }
-
-    @Test
-    fun `the pinch floor is the height FitDay resolves to`() {
-        // The inconsistency the issue is about: the two ways to reach "the whole
-        // day on one screen" have to arrive at the same height.
-        val density = Density(2.5f)
-        val viewport = 596.dp
-        with(density) {
-            val fitDay = TimelineScale.FitDay.hourHeight(viewport).toPx()
-            val pinched = pinchedHourHeightPx(
-                target = 1f,
-                fillPx = fillHourHeight(viewport).toPx(),
-                maxPx = MAX_PINCH_HOUR_HEIGHT.toPx(),
-            )
-            assertThat(pinched).isWithin(0.01f).of(fitDay)
-        }
-    }
-
     @Test
     fun `a settled pinch is what gets persisted`() {
         var persisted: TimelineScale? = null

gradle/libs.versions.toml

@@ -11,7 +11,7 @@ composeBom = "2026.06.01"
 # Material 3 Expressive APIs currently live only in the 1.5 alpha line.
 # Pin explicitly to override the BOM (which ships stable 1.4.0).
 # Re-evaluate when 1.5.0 stable lands.
-material3 = "1.5.0-alpha26"
+material3 = "1.5.0-alpha28"
 datastore = "1.2.1"
 junit = "6.1.3"
 junitPlatform = "6.1.3"