--- a/packages/SystemUI/customization/src/com/android/systemui/shared/clocks/ClockRegistry.kt
+++ b/packages/SystemUI/customization/src/com/android/systemui/shared/clocks/ClockRegistry.kt
@@ -432,7 +432,10 @@
     }
 
     var currentClockId: ClockId
-        get() = settings?.clockId ?: fallbackClockId
+        get() =
+            settings?.clockId
+                ?: fallbackClockId.takeUnless { it == DEFAULT_CLOCK_ID } // Vanta
+                ?: VANTA_CLOCK_ID
         set(value) {
             scope.launch(bgDispatcher) { mutateSetting { it.copy(clockId = value) } }
         }
@@ -464,6 +467,14 @@
             clock.replacementTarget?.let { replacementMap[clock.clockId] = it }
         }
 
+        // Vanta: the in-tree Vanta Lock clock sits beside the stock designs and is the default.
+        VantaClockProvider(context).let { vanta ->
+            vanta.initialize(clockBuffers)
+            for (clock in vanta.getClocks()) {
+                availableClocks[clock.clockId] = ClockInfo(clock, vanta, null)
+            }
+        }
+
         // Something has gone terribly wrong if the default clock isn't present
         if (!availableClocks.containsKey(DEFAULT_CLOCK_ID)) {
             throw IllegalArgumentException(
@@ -686,7 +697,7 @@
         ctx: Context,
         func: ClockController.() -> Unit = {},
     ): ClockController {
-        val clock = createClock(ctx, DEFAULT_CLOCK_ID)!!
+        val clock = createClock(ctx, VANTA_CLOCK_ID) ?: createClock(ctx, DEFAULT_CLOCK_ID)!!
         func(clock)
         return clock
     }
--- /dev/null
+++ b/packages/SystemUI/customization/src/com/android/systemui/shared/clocks/VantaClockController.kt
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2026 Vanta
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+package com.android.systemui.shared.clocks
+
+import android.content.Context
+import android.icu.util.TimeZone
+import com.android.systemui.customization.clocks.view.DefaultClockFaceLayout
+import com.android.systemui.plugins.keyguard.VRect
+import com.android.systemui.plugins.keyguard.data.model.AlarmData
+import com.android.systemui.plugins.keyguard.data.model.WeatherData
+import com.android.systemui.plugins.keyguard.data.model.ZenData
+import com.android.systemui.plugins.keyguard.ui.clocks.AodClockBurnInModel
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockAnimations
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockAxisStyle
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockConfig
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockController
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockEventListeners
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockEvents
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockFaceConfig
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockFaceController
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockFaceEvents
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockPositionAnimationArgs
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockSettings
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockTickRate
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockViewIds
+import com.android.systemui.plugins.keyguard.ui.clocks.ThemeConfig
+import com.android.systemui.plugins.keyguard.ui.clocks.TimeFormatKind
+import java.io.PrintWriter
+import java.util.Locale
+
+/**
+ * Controls the Vanta Lock clock.
+ *
+ * Large face: [VantaClockView] in the layout picked by `Settings.Secure` `vanta_lock_clock`
+ * ("split" default, "stack", "mono"). Small face: one line, "HH:MM". Shaped after
+ * [DefaultClockController]; every face draws itself, so there are no layouts to inflate.
+ */
+class VantaClockController(
+    private val ctx: Context,
+    private val settings: ClockSettings?,
+) : ClockController {
+    override val smallClock: VantaClockFaceController
+    override val largeClock: VantaClockFaceController
+    private val clocks: List<VantaClockView>
+
+    override val events: VantaClockEvents
+    override val config: ClockConfig by lazy { ClockConfig(VANTA_CLOCK_ID, NAME, DESCRIPTION) }
+    override val eventListeners = ClockEventListeners()
+
+    init {
+        smallClock =
+            VantaClockFaceController(
+                VantaClockView(ctx, isLarge = false).apply {
+                    id = ClockViewIds.LOCKSCREEN_CLOCK_VIEW_SMALL
+                },
+                settings?.seedColor,
+                ClockFaceConfig(tickRate = ClockTickRate.PER_MINUTE),
+            )
+        largeClock =
+            VantaClockFaceController(
+                VantaClockView(ctx, isLarge = true).apply {
+                    id = ClockViewIds.LOCKSCREEN_CLOCK_VIEW_LARGE
+                },
+                settings?.seedColor,
+                // The seconds line needs a tick every second; ClockEventController stops the
+                // ticker while dozing, where the line is hidden anyway.
+                ClockFaceConfig(tickRate = ClockTickRate.PER_SECOND),
+            )
+        clocks = listOf(smallClock.view, largeClock.view)
+
+        events = VantaClockEvents()
+        events.onLocaleChanged(Locale.getDefault())
+    }
+
+    override fun initialize(isDarkTheme: Boolean, dozeFraction: Float, foldFraction: Float) {
+        largeClock.animations = VantaClockAnimations(largeClock.view, dozeFraction, foldFraction)
+        smallClock.animations = VantaClockAnimations(smallClock.view, dozeFraction, foldFraction)
+
+        largeClock.events.onThemeChanged(largeClock.theme.copy(isDarkTheme = isDarkTheme))
+        smallClock.events.onThemeChanged(smallClock.theme.copy(isDarkTheme = isDarkTheme))
+        events.onTimeZoneChanged(TimeZone.getDefault())
+        events.onTimeFormatChanged(TimeFormatKind.getFromContext(ctx))
+
+        smallClock.events.onTimeTick()
+        largeClock.events.onTimeTick()
+    }
+
+    inner class VantaClockFaceController(
+        override val view: VantaClockView,
+        seedColor: Int?,
+        override val config: ClockFaceConfig,
+    ) : ClockFaceController {
+        override var theme = ThemeConfig(true, seedColor)
+
+        override val layout =
+            object : DefaultClockFaceLayout(view) {
+                // The host still owns the coarse burn-in translation of the clock container;
+                // the view adds its own ±12px per-minute walk on top (see VantaClockView).
+                override fun applyAodBurnIn(aodBurnInModel: AodClockBurnInModel) {
+                    this@VantaClockFaceController.view.applyBurnIn(aodBurnInModel.scale)
+                }
+            }
+
+        override var animations: VantaClockAnimations = VantaClockAnimations(view, 0f, 0f)
+            internal set
+
+        init {
+            view.setColors(isDarkTheme = true, accent = seedColor ?: vantaAccent(ctx))
+        }
+
+        override val events =
+            object : ClockFaceEvents {
+                override fun onTimeTick() = view.refreshTime()
+
+                override fun onThemeChanged(theme: ThemeConfig) {
+                    this@VantaClockFaceController.theme = theme
+                    val accent =
+                        theme.seedColor
+                            ?: if (theme.isDarkTheme) {
+                                vantaAccent(ctx)
+                            } else {
+                                ctx.resources.getColor(android.R.color.system_accent1_600, null)
+                            }
+                    view.setColors(theme.isDarkTheme, accent)
+                }
+
+                override fun onFontSettingChanged(fontSizePx: Float) {
+                    view.setTextSizePx(fontSizePx)
+                }
+
+                @Deprecated("No longer necessary, pending removal")
+                override fun onTargetRegionChanged(targetRegion: VRect) {}
+
+                override fun onSecondaryDisplayChanged(onSecondaryDisplay: Boolean) {}
+            }
+    }
+
+    inner class VantaClockEvents : ClockEvents {
+        override fun onTimeFormatChanged(formatKind: TimeFormatKind) =
+            clocks.forEach { it.setIs24Hour(formatKind == TimeFormatKind.FULL_DAY) }
+
+        override fun onTimeZoneChanged(timeZone: TimeZone) {
+            val legacyTimezone = java.util.TimeZone.getTimeZone(timeZone.getID())
+            clocks.forEach { it.setTimeZone(legacyTimezone) }
+        }
+
+        override fun onLocaleChanged(locale: Locale) {
+            clocks.forEach { it.setLocale(locale) }
+        }
+
+        override fun onWeatherDataChanged(data: WeatherData) = clocks.forEach { it.setWeather(data) }
+
+        override fun onAlarmDataChanged(data: AlarmData) = clocks.forEach { it.setAlarm(data) }
+
+        override fun onZenDataChanged(data: ZenData) {}
+    }
+
+    inner class VantaClockAnimations(
+        val view: VantaClockView,
+        dozeFraction: Float,
+        foldFraction: Float,
+    ) : ClockAnimations {
+        init {
+            view.setDozeFraction(dozeFraction)
+            view.setFoldFraction(foldFraction)
+        }
+
+        override fun enter() {
+            if (!view.isDozing) view.animateEnter()
+        }
+
+        override fun doze(fraction: Float) = view.setDozeFraction(fraction)
+
+        override fun fold(fraction: Float) = view.setFoldFraction(fraction)
+
+        override fun charge() {
+            if (!view.isDozing) view.animateCharge()
+        }
+
+        override fun onPositionAnimated(anim: ClockPositionAnimationArgs) {}
+
+        override fun onPickerCarouselSwiping(swipingFraction: Float) {
+            // Same offset DefaultClockController applies so the picker carousel lines up.
+            view.translationY = 0.5f * view.bottom * (1 - swipingFraction)
+        }
+
+        override fun onFidgetTap(x: Float, y: Float) = view.animateTap()
+
+        override fun onFontAxesChanged(style: ClockAxisStyle) {}
+    }
+
+    override fun dump(pw: PrintWriter) {
+        pw.print("smallClock=")
+        smallClock.view.dump(pw)
+        pw.print("largeClock=")
+        largeClock.view.dump(pw)
+    }
+
+    companion object {
+        const val NAME = "Vanta"
+        const val DESCRIPTION = "Split clock: hours over minutes, a line of light for the seconds"
+
+        /** `Settings.Secure` key the Vanta Hub writes: "split" | "stack" | "mono". */
+        const val SETTING_LOCK_CLOCK = "vanta_lock_clock"
+
+        /** `Settings.Secure` key for Vanta Ambient: "weather" | "clock" | "media" | "minimal". */
+        const val SETTING_AMBIENT_STYLE = "vanta_ambient_style"
+    }
+}
--- /dev/null
+++ b/packages/SystemUI/customization/src/com/android/systemui/shared/clocks/VantaClockProvider.kt
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2026 Vanta
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+package com.android.systemui.shared.clocks
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.Paint
+import android.graphics.PixelFormat
+import android.graphics.Typeface
+import android.graphics.drawable.Drawable
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockController
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockMessageBuffers
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockMetadata
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockPickerConfig
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockProvider
+import com.android.systemui.plugins.keyguard.ui.clocks.ClockSettings
+
+private val TAG = VantaClockProvider::class.simpleName
+
+/** Id of the Vanta Lock clock. ClockRegistry treats it as the system default face. */
+const val VANTA_CLOCK_ID = "VANTA_CLOCK"
+
+/**
+ * Provides the Vanta Lock clock: a split clock (hours over minutes, a seconds line of accent
+ * light between them). Registered in-tree by [ClockRegistry] next to [DefaultClockProvider].
+ */
+class VantaClockProvider(private val context: Context) : ClockProvider {
+
+    override fun initialize(buffers: ClockMessageBuffers?) {
+        // The Vanta clock draws itself; it keeps no debug log buffers.
+    }
+
+    override fun getClocks(): List<ClockMetadata> = listOf(ClockMetadata(VANTA_CLOCK_ID))
+
+    override fun createClock(ctx: Context, settings: ClockSettings): ClockController {
+        if (getClocks().all { it.clockId != settings.clockId }) {
+            throw IllegalArgumentException("${settings.clockId} is unsupported by $TAG")
+        }
+        return VantaClockController(ctx, settings)
+    }
+
+    override fun getClockPickerConfig(settings: ClockSettings): ClockPickerConfig {
+        if (getClocks().all { it.clockId != settings.clockId }) {
+            throw IllegalArgumentException("${settings.clockId} is unsupported by $TAG")
+        }
+        return ClockPickerConfig(
+            id = VANTA_CLOCK_ID,
+            name = VantaClockController.NAME,
+            description = VantaClockController.DESCRIPTION,
+            thumbnail = VantaClockThumbnail(settings.seedColor ?: vantaAccent(context)),
+            isReactiveToTone = true,
+            axes = emptyList(),
+            presetConfig = null,
+        )
+    }
+}
+
+/** The Monet accent Vanta ships (#35E0FF) at the tone the lock screen draws with. */
+internal fun vantaAccent(context: Context): Int =
+    context.resources.getColor(android.R.color.system_accent1_200, null)
+
+/** Picker thumbnail: "10" white over "09" accent, the split clock in miniature. */
+private class VantaClockThumbnail(private val accent: Int) : Drawable() {
+    private val paint =
+        Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            typeface = Typeface.create("sans-serif-thin", Typeface.NORMAL)
+            textAlign = Paint.Align.CENTER
+        }
+
+    override fun draw(canvas: Canvas) {
+        val b = bounds
+        val cx = b.exactCenterX()
+        paint.textSize = b.height() * 0.42f
+        canvas.drawColor(Color.BLACK)
+        paint.color = Color.WHITE
+        canvas.drawText("10", cx, b.top + b.height() * 0.46f, paint)
+        paint.color = accent
+        canvas.drawRect(cx - b.width() * 0.2f, b.top + b.height() * 0.52f,
+            cx + b.width() * 0.08f, b.top + b.height() * 0.535f, paint)
+        canvas.drawText("09", cx, b.top + b.height() * 0.92f, paint)
+    }
+
+    override fun setAlpha(alpha: Int) {
+        paint.alpha = alpha
+    }
+
+    override fun setColorFilter(colorFilter: ColorFilter?) {
+        paint.colorFilter = colorFilter
+    }
+
+    @Deprecated("Deprecated in Java")
+    override fun getOpacity(): Int = PixelFormat.OPAQUE
+
+    override fun getIntrinsicWidth(): Int = 144
+
+    override fun getIntrinsicHeight(): Int = 144
+}
--- /dev/null
+++ b/packages/SystemUI/customization/src/com/android/systemui/shared/clocks/VantaClockView.kt
@@ -0,0 +1,638 @@
+/*
+ * Copyright (C) 2026 Vanta
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+package com.android.systemui.shared.clocks
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.LinearGradient
+import android.graphics.Paint
+import android.graphics.Rect
+import android.graphics.Shader
+import android.graphics.Typeface
+import android.icu.text.DateFormat
+import android.icu.text.DisplayContext
+import android.media.session.MediaSessionManager
+import android.media.session.PlaybackState
+import android.provider.Settings
+import android.text.format.DateFormat as AndroidDateFormat
+import android.view.View
+import android.view.animation.DecelerateInterpolator
+import android.view.animation.OvershootInterpolator
+import com.android.systemui.customization.clocks.R as clocksR
+import java.io.PrintWriter
+import com.android.systemui.plugins.keyguard.data.model.AlarmData
+import com.android.systemui.plugins.keyguard.data.model.WeatherData
+import java.util.Calendar
+import java.util.Locale
+import java.util.TimeZone
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * One face of the Vanta Lock clock, drawn directly on the canvas.
+ *
+ * Large faces follow `Settings.Secure` `vanta_lock_clock`:
+ * - "split" (default): hours (white) stacked over minutes (accent) in very large thin type, a
+ *   2dp line of accent light between them that grows with the seconds.
+ * - "stack": the date in small accent capitals over a one-line thin "HH:MM".
+ * - "mono": a small one-line "HH:MM" in the top-left corner.
+ *
+ * The small face is always one line "HH:MM".
+ *
+ * Doze/AOD: white drops to 40%, the accent drops to a thin outline, the seconds line goes dark,
+ * and the drawing walks up to ±12px each minute against burn-in.
+ *
+ * Vanta Ambient: while dozing, the large face adds one quiet line under the time, picked by
+ * `Settings.Secure` `vanta_ambient_style` (mirrored from the Hub's Studio page):
+ * - "weather" (default): the date and the current temperature + description.
+ * - "clock": the date alone.
+ * - "media": what is playing, read from the active media session.
+ * - "minimal": no line, and the clock shrinks to 60% so fewer pixels stay lit.
+ * The next alarm rides on the end of any line. The row is reserved awake too, so going to
+ * sleep never moves the clock.
+ */
+class VantaClockView(context: Context, val isLarge: Boolean) : View(context) {
+
+    private enum class Style { SPLIT, STACK, MONO, SMALL }
+
+    private val density = resources.displayMetrics.density
+    private val thin = Typeface.create("sans-serif-thin", Typeface.NORMAL)
+    private val light = Typeface.create("sans-serif-light", Typeface.NORMAL)
+    private val medium = Typeface.create("sans-serif-medium", Typeface.NORMAL)
+
+    private val hourPaint = textPaint(thin)
+    private val minutePaint = textPaint(thin)
+    private val outlinePaint =
+        textPaint(thin).apply {
+            style = Paint.Style.STROKE
+            strokeWidth = 1.2f * density
+        }
+    private val datePaint = textPaint(medium).apply { letterSpacing = 0.18f }
+    private val linePaint = Paint(Paint.ANTI_ALIAS_FLAG)
+    private val ambientPaint = textPaint(light).apply { letterSpacing = 0.06f }
+    private val digitBounds = Rect()
+
+    private var style = if (isLarge) readStyle() else Style.SMALL
+    private var baseTextSize =
+        resources.getDimension(
+            if (isLarge) clocksR.dimen.large_clock_text_size else clocksR.dimen.small_clock_text_size
+        )
+
+    private val calendar = Calendar.getInstance()
+    private var locale: Locale = Locale.getDefault()
+    private var is24Hour = AndroidDateFormat.is24HourFormat(context)
+    private var dateFormat: DateFormat = buildDateFormat()
+    private var hours = "00"
+    private var minutes = "00"
+    private var date = ""
+    private var lastMinute = -1
+
+    private var ambient = if (isLarge) readAmbient() else Ambient.NONE
+    private var weather: WeatherData? = null
+    private var alarmMillis: Long? = null
+    private var media = ""
+    private var ambientLine = ""
+
+    private var white = Color.WHITE
+    private var accent = Color.CYAN
+
+    private var dozeFraction = 0f
+    val isDozing: Boolean
+        get() = dozeFraction > 0.5f
+
+    private var foldFraction = 0f
+    private var burnInScale = 1f
+    private var shiftX = 0f
+    private var shiftY = 0f
+
+    // Motion: everything that moves is an overshoot, so it lands with a little spring.
+    private var secondsFraction = 0f
+    private var secondsAnimator: ValueAnimator? = null
+    private var enterFraction = 1f
+    private var enterAnimator: ValueAnimator? = null
+    private var chargeFraction = 0f
+    private var chargeAnimator: ValueAnimator? = null
+    private var tapScale = 1f
+    private var tapAnimator: ValueAnimator? = null
+
+    init {
+        applyTextSizes()
+        refreshTime()
+    }
+
+    // ---- inputs from VantaClockController ----------------------------------------------------
+
+    fun setColors(isDarkTheme: Boolean, accent: Int) {
+        this.white = if (isDarkTheme) Color.WHITE else VOID_GLASS
+        this.accent = accent
+        linePaint.shader = null // rebuilt on the next draw with the new accent
+        invalidate()
+    }
+
+    fun setTextSizePx(px: Float) {
+        if (!isLarge || px <= 0f || px == baseTextSize) return
+        baseTextSize = px
+        applyTextSizes()
+        requestLayout()
+        invalidate()
+    }
+
+    fun setIs24Hour(is24: Boolean) {
+        if (is24Hour == is24) return
+        is24Hour = is24
+        lastMinute = -1
+        refreshTime()
+    }
+
+    fun setTimeZone(timeZone: TimeZone) {
+        calendar.timeZone = timeZone
+        dateFormat = buildDateFormat()
+        lastMinute = -1
+        refreshTime()
+    }
+
+    fun setLocale(locale: Locale) {
+        this.locale = locale
+        dateFormat = buildDateFormat()
+        lastMinute = -1
+        refreshTime()
+    }
+
+    fun setWeather(data: WeatherData?) {
+        weather = data
+        rebuildAmbientLine()
+    }
+
+    fun setAlarm(data: AlarmData) {
+        alarmMillis = data.nextAlarmMillis
+        rebuildAmbientLine()
+    }
+
+    fun setDozeFraction(fraction: Float) {
+        val f = fraction.coerceIn(0f, 1f)
+        if (f == dozeFraction) return
+        if (isLarge && f > 0f && dozeFraction == 0f) {
+            // Falling asleep: pick up a Studio change and what is playing right now.
+            ambient = readAmbient()
+            if (ambient == Ambient.MEDIA) media = readMedia()
+            rebuildAmbientLine()
+        }
+        dozeFraction = f
+        if (f > 0f) {
+            secondsAnimator?.cancel()
+            enterAnimator?.cancel()
+            enterFraction = 1f
+        }
+        updateBurnInShift()
+        invalidate()
+    }
+
+    fun setFoldFraction(fraction: Float) {
+        foldFraction = fraction.coerceIn(0f, 1f)
+        invalidate()
+    }
+
+    fun applyBurnIn(scale: Float) {
+        burnInScale = if (scale > 0f) scale else 1f
+        invalidate()
+    }
+
+    fun refreshTime() {
+        calendar.timeInMillis = System.currentTimeMillis()
+        val minute = calendar.get(Calendar.MINUTE)
+        if (minute != lastMinute) {
+            lastMinute = minute
+            val h =
+                if (is24Hour) {
+                    calendar.get(Calendar.HOUR_OF_DAY)
+                } else {
+                    calendar.get(Calendar.HOUR).let { if (it == 0) 12 else it }
+                }
+            hours = String.format(locale, "%02d", h)
+            minutes = String.format(locale, "%02d", minute)
+            date = dateFormat.format(calendar.time).uppercase(locale)
+            contentDescription =
+                if (style == Style.STACK) "$date $hours:$minutes" else "$hours:$minutes"
+            if (isLarge) {
+                ambient = readAmbient()
+                if (ambient == Ambient.MEDIA && isDozing) media = readMedia()
+                rebuildAmbientLine()
+                val newStyle = readStyle()
+                if (newStyle != style) {
+                    style = newStyle
+                    applyTextSizes()
+                }
+            }
+            updateBurnInShift()
+            requestLayout()
+        }
+        if (style == Style.SPLIT) {
+            animateSecondsTo((calendar.get(Calendar.SECOND) + 1) / 60f)
+        }
+        invalidate()
+    }
+
+    // ---- animations ------------------------------------------------------------------------
+
+    fun animateEnter() {
+        enterAnimator?.cancel()
+        enterAnimator =
+            ValueAnimator.ofFloat(0f, 1f).apply {
+                duration = SLOW_MS
+                interpolator = OvershootInterpolator(1.2f)
+                addUpdateListener {
+                    enterFraction = it.animatedValue as Float
+                    invalidate()
+                }
+                start()
+            }
+    }
+
+    /** Plug-in: the seconds line floods to full length and swells, then settles back. */
+    fun animateCharge() {
+        chargeAnimator?.cancel()
+        chargeAnimator =
+            ValueAnimator.ofFloat(0f, 1f, 0f).apply {
+                duration = SLOW_MS * 3
+                interpolator = DecelerateInterpolator()
+                addUpdateListener {
+                    chargeFraction = it.animatedValue as Float
+                    invalidate()
+                }
+                start()
+            }
+    }
+
+    fun animateTap() {
+        tapAnimator?.cancel()
+        tapAnimator =
+            ValueAnimator.ofFloat(0.96f, 1f).apply {
+                duration = BASE_MS * 2
+                interpolator = OvershootInterpolator(3f)
+                addUpdateListener {
+                    tapScale = it.animatedValue as Float
+                    invalidate()
+                }
+                start()
+            }
+    }
+
+    private fun animateSecondsTo(target: Float) {
+        secondsAnimator?.cancel()
+        if (isDozing || !isAttachedToWindow || target < secondsFraction) {
+            // Wrap at the minute (or no frame clock): jump, don't sweep backwards.
+            secondsFraction = target
+            return
+        }
+        secondsAnimator =
+            ValueAnimator.ofFloat(secondsFraction, target).apply {
+                duration = BASE_MS * 2
+                interpolator = OvershootInterpolator(0.8f)
+                addUpdateListener {
+                    secondsFraction = it.animatedValue as Float
+                    invalidate()
+                }
+                start()
+            }
+    }
+
+    // ---- layout ------------------------------------------------------------------------------
+
+    private fun applyTextSizes() {
+        val big = baseTextSize
+        when (style) {
+            Style.SPLIT -> {
+                hourPaint.typeface = thin
+                minutePaint.typeface = thin
+                hourPaint.textSize = big
+            }
+            Style.STACK -> {
+                hourPaint.typeface = thin
+                minutePaint.typeface = thin
+                hourPaint.textSize = big * 0.58f
+                datePaint.textSize = big * 0.13f
+            }
+            Style.MONO -> {
+                hourPaint.typeface = light
+                minutePaint.typeface = light
+                hourPaint.textSize = big * 0.3f
+            }
+            Style.SMALL -> {
+                hourPaint.typeface = light
+                minutePaint.typeface = light
+                hourPaint.textSize = big
+            }
+        }
+        minutePaint.textSize = hourPaint.textSize
+        ambientPaint.textSize = max(baseTextSize * 0.09f, 13f * density)
+        outlinePaint.typeface = minutePaint.typeface
+        outlinePaint.textSize = minutePaint.textSize
+        hourPaint.getTextBounds("0123456789", 0, 10, digitBounds)
+    }
+
+    private val digitHeight: Float
+        get() = digitBounds.height().toFloat()
+
+    private val gap: Float
+        get() = digitHeight * 0.2f
+
+    /** Every face reserves the burn-in walk on each side so the shift never clips. */
+    private val pad: Float
+        get() = BURN_IN_PX
+
+    private fun contentWidth(): Float =
+        when (style) {
+            Style.SPLIT -> max(hourPaint.measureText("00"), minutePaint.measureText("00"))
+            Style.STACK ->
+                max(hourPaint.measureText("00:00"), datePaint.measureText(date))
+            Style.MONO,
+            Style.SMALL -> hourPaint.measureText("$hours:$minutes")
+        }
+
+    private fun contentHeight(): Float =
+        when (style) {
+            Style.SPLIT -> digitHeight * 2 + gap * 2 + LINE_DP * density
+            Style.STACK -> datePaint.textSize + gap + digitHeight
+            Style.MONO,
+            Style.SMALL -> digitHeight
+        }
+
+    /** The Ambient row under a large face: reserved whenever an Ambient style can draw one. */
+    private fun ambientRow(): Float =
+        if (isLarge && ambient != Ambient.NONE && ambient != Ambient.MINIMAL) ambientPaint.textSize * 2.2f
+        else 0f
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        val wantW = (contentWidth() + pad * 2).toInt()
+        val wantH = (contentHeight() + ambientRow() + pad * 2).toInt()
+        val w =
+            if (style == Style.MONO && MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.UNSPECIFIED) {
+                // Mono pins itself top-left: take the whole row, draw at its start.
+                max(wantW, MeasureSpec.getSize(widthMeasureSpec))
+            } else {
+                resolveSize(wantW, widthMeasureSpec)
+            }
+        setMeasuredDimension(w, resolveSize(wantH, heightMeasureSpec))
+    }
+
+    // ---- drawing -----------------------------------------------------------------------------
+
+    override fun onDraw(canvas: Canvas) {
+        val d = dozeFraction
+        val awake = 1f - d
+        val fade = min(1f, enterFraction.coerceAtLeast(0f)) * (1f - foldFraction)
+        if (fade <= 0f) return
+
+        canvas.save()
+        val cx = width / 2f
+        val cy = (height - ambientRow()) / 2f
+        val minimal = if (ambient == Ambient.MINIMAL) 1f - 0.4f * d else 1f
+        val scale = burnInScale * tapScale * minimal
+        canvas.scale(scale, scale, cx, cy)
+        canvas.translate(shiftX * d, shiftY * d + (1f - enterFraction) * ENTER_RISE_DP * density)
+
+        // White: 100% awake -> 40% in AOD.
+        val whiteAlpha = (255 * fade * (1f - 0.6f * d)).toInt()
+        hourPaint.color = white
+        hourPaint.alpha = whiteAlpha
+        // Accent: solid awake -> thin outline in AOD.
+        minutePaint.color = accent
+        minutePaint.alpha = (255 * fade * awake).toInt()
+        outlinePaint.color = accent
+        outlinePaint.alpha = (255 * fade * d * 0.8f).toInt()
+
+        canvas.save()
+        // Centred faces make room for the Ambient row; mono is pinned top-left and stays put.
+        if (style != Style.MONO) canvas.translate(0f, -ambientRow() / 2f)
+        when (style) {
+            Style.SPLIT -> drawSplit(canvas, cx, fade * awake)
+            Style.STACK -> drawStack(canvas, cx, fade, whiteAlpha)
+            Style.MONO,
+            Style.SMALL -> drawLine(canvas, pad)
+        }
+        canvas.restore()
+        drawAmbient(canvas, cx, fade * d)
+        canvas.restore()
+    }
+
+    /** The Ambient line: dim white, centred under the time (start-aligned under mono). */
+    private fun drawAmbient(canvas: Canvas, cx: Float, alpha: Float) {
+        if (alpha <= 0f || ambientRow() == 0f || ambientLine.isEmpty()) return
+        val y = height - pad - ambientRow() * 0.35f
+        ambientPaint.color = white
+        ambientPaint.alpha = (255 * alpha * 0.55f).toInt()
+        if (style == Style.MONO) {
+            ambientPaint.textAlign = Paint.Align.LEFT
+            canvas.drawText(ambientLine, pad, y, ambientPaint)
+        } else {
+            ambientPaint.textAlign = Paint.Align.CENTER
+            canvas.drawText(ambientLine, cx, y, ambientPaint)
+        }
+    }
+
+    private fun rebuildAmbientLine() {
+        val parts = ArrayList<String>(3)
+        when (ambient) {
+            Ambient.CLOCK -> parts += date
+            Ambient.WEATHER -> {
+                parts += date
+                weather?.let { w ->
+                    val t = "${w.temperature}\u00B0${if (w.useCelsius) "C" else "F"}"
+                    parts += if (w.description.isBlank()) t else "$t ${w.description}"
+                }
+            }
+            Ambient.MEDIA -> parts += media.ifEmpty { date }
+            Ambient.MINIMAL,
+            Ambient.NONE -> {}
+        }
+        alarmMillis?.let { at ->
+            if (ambient != Ambient.MINIMAL && ambient != Ambient.NONE && at - System.currentTimeMillis() in 0..ALARM_HORIZON_MS) {
+                parts += "\u23F0 " + AndroidDateFormat.format(if (is24Hour) "HH:mm" else "h:mm", at)
+            }
+        }
+        val next = parts.filter { it.isNotBlank() }.joinToString("  \u00B7  ")
+        if (next != ambientLine) {
+            ambientLine = next
+            invalidate()
+        }
+    }
+
+    /** Title and artist of the playing session; SystemUI holds MEDIA_CONTENT_CONTROL. */
+    private fun readMedia(): String =
+        try {
+            context.getSystemService(MediaSessionManager::class.java)
+                ?.getActiveSessions(null)
+                ?.firstOrNull { it.playbackState?.state == PlaybackState.STATE_PLAYING }
+                ?.metadata
+                ?.let { m ->
+                    val title = m.getString(android.media.MediaMetadata.METADATA_KEY_TITLE).orEmpty()
+                    val artist = m.getString(android.media.MediaMetadata.METADATA_KEY_ARTIST).orEmpty()
+                    listOf(title, artist).filter { it.isNotBlank() }.joinToString(" \u2014 ")
+                }
+                .orEmpty()
+        } catch (_: SecurityException) {
+            ""
+        }
+
+    private fun drawSplit(canvas: Canvas, cx: Float, lineAlpha: Float) {
+        hourPaint.textAlign = Paint.Align.CENTER
+        minutePaint.textAlign = Paint.Align.CENTER
+        outlinePaint.textAlign = Paint.Align.CENTER
+
+        val top = (height - contentHeight()) / 2f
+        val hourBase = top + digitHeight
+        val lineY = hourBase + gap
+        val minuteBase = lineY + LINE_DP * density + gap + digitHeight
+
+        canvas.drawText(hours, cx, hourBase, hourPaint)
+        drawMinutes(canvas, minutes, cx, minuteBase)
+
+        if (lineAlpha > 0f) {
+            val w = contentWidth()
+            val left = cx - w / 2f
+            val grow = max(secondsFraction, chargeFraction).coerceIn(0f, 1.05f)
+            ensureLineShader(left, w)
+            linePaint.alpha = (255 * lineAlpha).toInt()
+            val thick = LINE_DP * density * (1f + chargeFraction)
+            canvas.drawRect(left, lineY, left + w * grow, lineY + thick, linePaint)
+        }
+    }
+
+    private fun drawStack(canvas: Canvas, cx: Float, fade: Float, whiteAlpha: Int) {
+        datePaint.textAlign = Paint.Align.CENTER
+        datePaint.color = accent
+        // The date is accent type: solid awake, dimmed to the AOD white level asleep.
+        datePaint.alpha = (255 * fade * (1f - 0.6f * dozeFraction)).toInt()
+        hourPaint.textAlign = Paint.Align.CENTER
+        hourPaint.alpha = whiteAlpha
+
+        val top = (height - contentHeight()) / 2f
+        canvas.drawText(date, cx, top + datePaint.textSize, datePaint)
+        canvas.drawText(
+            "$hours:$minutes",
+            cx,
+            top + datePaint.textSize + gap + digitHeight,
+            hourPaint,
+        )
+    }
+
+    /** One line, start-aligned: hours white, ":MM" accent. Used by mono and the small face. */
+    private fun drawLine(canvas: Canvas, x: Float) {
+        hourPaint.textAlign = Paint.Align.LEFT
+        minutePaint.textAlign = Paint.Align.LEFT
+        outlinePaint.textAlign = Paint.Align.LEFT
+        val baseline = pad + digitHeight
+        canvas.drawText(hours, x, baseline, hourPaint)
+        drawMinutes(canvas, ":$minutes", x + hourPaint.measureText(hours), baseline)
+    }
+
+    private fun drawMinutes(canvas: Canvas, text: String, x: Float, baseline: Float) {
+        if (minutePaint.alpha > 0) canvas.drawText(text, x, baseline, minutePaint)
+        if (outlinePaint.alpha > 0) canvas.drawText(text, x, baseline, outlinePaint)
+    }
+
+    private var shaderLeft = Float.NaN
+    private var shaderWidth = Float.NaN
+
+    /** The lit rim: accent fading to the Vanta edge_dim (#1B6F80) along the line. */
+    private fun ensureLineShader(left: Float, w: Float) {
+        if (linePaint.shader != null && left == shaderLeft && w == shaderWidth) return
+        shaderLeft = left
+        shaderWidth = w
+        linePaint.shader =
+            LinearGradient(left, 0f, left + w, 0f, accent, EDGE_DIM, Shader.TileMode.CLAMP)
+    }
+
+    // ---- helpers -----------------------------------------------------------------------------
+
+    /** Walk the drawing up to ±[BURN_IN_PX] each minute, a different spot every minute. */
+    private fun updateBurnInShift() {
+        val m = if (lastMinute < 0) 0 else lastMinute
+        shiftX = BURN_IN_STEPS[m % BURN_IN_STEPS.size] * BURN_IN_PX
+        shiftY = BURN_IN_STEPS[(m + 3) % BURN_IN_STEPS.size] * BURN_IN_PX
+    }
+
+    private fun readStyle(): Style =
+        when (
+            Settings.Secure.getString(
+                context.contentResolver,
+                VantaClockController.SETTING_LOCK_CLOCK,
+            )
+        ) {
+            "stack" -> Style.STACK
+            "mono" -> Style.MONO
+            else -> Style.SPLIT
+        }
+
+    private enum class Ambient { CLOCK, WEATHER, MEDIA, MINIMAL, NONE }
+
+    private fun readAmbient(): Ambient =
+        when (
+            Settings.Secure.getString(
+                context.contentResolver,
+                VantaClockController.SETTING_AMBIENT_STYLE,
+            )
+        ) {
+            "clock" -> Ambient.CLOCK
+            "media" -> Ambient.MEDIA
+            "minimal" -> Ambient.MINIMAL
+            else -> Ambient.WEATHER
+        }
+
+    private fun buildDateFormat(): DateFormat {
+        // Read our java.util.Calendar's zone out here: inside apply{} `calendar` would resolve
+        // to the DateFormat's own ICU calendar.
+        val zone = android.icu.util.TimeZone.getTimeZone(calendar.timeZone.id)
+        return DateFormat.getInstanceForSkeleton("EEEMMMd", locale).apply {
+            setContext(DisplayContext.CAPITALIZATION_FOR_STANDALONE)
+            timeZone = zone
+        }
+    }
+
+    private fun textPaint(face: Typeface) =
+        Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            typeface = face
+            fontFeatureSettings = "tnum"
+            isSubpixelText = true
+        }
+
+    fun dump(pw: PrintWriter) {
+        pw.println(
+            "VantaClockView(large=$isLarge style=$style time=$hours:$minutes " +
+                "ambient=$ambient line=\"$ambientLine\" doze=$dozeFraction shift=($shiftX,$shiftY) size=$baseTextSize)"
+        )
+    }
+
+    companion object {
+        private const val LINE_DP = 2f
+        private const val ENTER_RISE_DP = 24f
+        private const val BURN_IN_PX = 12f
+        private const val BASE_MS = 240L
+        private const val SLOW_MS = 420L
+
+        /** An alarm joins the Ambient line only if it rings within the next 12 hours. */
+        private const val ALARM_HORIZON_MS = 12L * 60 * 60 * 1000
+
+        /** Vanta Void rim tail colour (tokens: void.colors.edge_dim). */
+        private const val EDGE_DIM = 0xFF1B6F80.toInt()
+
+        /** Near-black glass (tokens: void.colors.surface), used as "white" on light themes. */
+        private const val VOID_GLASS = 0xFF0A0D10.toInt()
+
+        /** Normalised offsets in [-1, 1]; with ×12px this never rests twice in a row. */
+        private val BURN_IN_STEPS = floatArrayOf(0f, 0.5f, 1f, 0.5f, -0.5f, -1f, -0.5f, 0.25f, -0.25f)
+    }
+}
