Merge pull request #380 from rosuH/codex/s3b-textmeasurer-cjk-baseline

S3b: Adopt TextMeasurer for watermark measurement

Author: rosuH

app/src/androidTest/java/me/rosuh/easywatermark/render/WatermarkCellInstrumentedGoldenTest.kt

@@ -8,6 +8,7 @@ import android.net.Uri
 import android.text.TextPaint
 import android.util.Log
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import me.rosuh.easywatermark.data.model.ImageInfo
@@ -37,7 +38,11 @@ class WatermarkCellInstrumentedGoldenTest {
         val imageInfo = ImageInfo.empty().apply { width = 1000; height = 1000 }
         val paint = TextPaint().applyConfig(imageInfo, config, isScale = false)
         val shader = runBlocking {
-            WaterMarkImageView.buildTextBitmapShader(imageInfo, config, paint, Dispatchers.Unconfined)
+            WaterMarkImageView.buildTextBitmapShader(
+                imageInfo, config, paint,
+                androidTextMeasureEnv(InstrumentationRegistry.getInstrumentation().targetContext),
+                Dispatchers.Unconfined,
+            )
         }!!
         val w = shader.width.coerceAtLeast(1)
         val h = shader.height.coerceAtLeast(1)

app/src/androidTest/java/me/rosuh/easywatermark/render/WatermarkCellParityGateTest.kt

@@ -17,64 +17,73 @@ import org.junit.runner.RunWith
 import kotlin.math.max
 
 /**
- * C2b **candidate signed-baseline** measurement gate. NOT product code; not wired into
- * `WaterMarkImageView`/`MainViewModel`.
+ * C2b **accepted signed-baseline** measurement gate (S3b / D1). The `TextMeasurer` measurement seam
+ * [WatermarkTextMeasurer] + [TextMeasureEnv] is now wired into the product renderer
+ * ([me.rosuh.easywatermark.render.WatermarkRenderer.buildTextShader]) for text-cell measurement
+ * (drawing stays legacy `StaticLayout`); this gate pins the same seam the product uses. Signed-baseline
+ * behavior: non-CJK strict legacy==seam (width AND height); CJK exact width + exact signed delta +
+ * exact signed absolute baseline (no tolerance widening; every row logged `PARITYGATE|…`).
  *
- * The candidate `TextMeasurer` measurement now lives behind the extracted seam
- * [WatermarkTextMeasurer] + [TextMeasureEnv] (app module `render/`, ACSP 20260614-002242) instead of
- * inline here — the gate exercises the same seam the future C2b renderer will use. Signed-baseline
- * behavior is unchanged: non-CJK strict legacy==seam (width AND height); CJK exact width + exact signed
- * delta + exact signed absolute baseline (no tolerance widening; every row logged `PARITYGATE|…`).
+ * ACCEPTED (S3b) — the CJK baselines encode "Option 1" (Compose CJK line-height accepted as the
+ * renderer baseline), promoted from candidate per the accepted D1 sign-off (ADR-0014/ADR-0004).
  *
- * CANDIDATE STATUS — the CJK baselines encode "Option 1" (accept Compose CJK line-height as the C2b
- * future-renderer baseline), pending coordinator/product sign-off (ADR-0014 candidate note). No product
- * renderer/export is wired.
+ * PLATFORM-PINNED (ADR-0010): the CJK absolute baselines below are a same-platform device baseline. Under
+ * the updated device policy (2026-06-14: any available adb target is acceptable, do not require a
+ * specific serial) they were re-pinned to the **acceptance target used for S3b verification:
+ * emulator-5554 / AVD Pixel_9_Pro_XL / Android 16 / API 36** (model `sdk_gphone64_arm64`). Robolectric
+ * is not a CJK dimension oracle; this gate is instrumented/device-only. Non-CJK rows assert parity and
+ * delta only, because their absolute glyph advances are device-font dependent under the any-device
+ * policy. Re-baseline the CJK absolute rows on the pinned CI device if the fleet changes.
  *
- * PLATFORM-PINNED (ADR-0010): the absolute baselines below are a same-platform device baseline (Samsung
- * SM-S906E / Android 16 / API 36 CJK font). Robolectric is not a CJK dimension oracle; this gate is
- * instrumented/device-only. The CJK *absolute* assertions are device-pinned and only pass on that
- * baseline device — the legacy==seam *parity* + signed *delta* assertions are device-independent.
- * Re-baseline on the pinned CI device if the device fleet changes.
+ * Device note: CJK *heights* matched the earlier SM-S906E baseline exactly (18/35/70/140); only the
+ * CJK glyph *widths* differed by a few px (wider Noto font) — recorded here, not treated as a blocker
+ * (updated policy).
  */
 @RunWith(AndroidJUnit4::class)
 class WatermarkCellParityGateTest {
 
     private val tag = "PARITYGATE"
 
     /**
-     * One gate row. `seamW`/`seamH` = the signed absolute baseline (API-36 device); `dH` = the signed
-     * legacy→seam height delta (0 for non-CJK). Width delta is always 0 (asserted).
+     * One gate row. `seamW`/`seamH` = the CJK signed absolute baseline (API-36 device); `dH` = the
+     * signed legacy→seam height delta (0 for non-CJK). Width delta is always 0 (asserted).
      */
     private data class Baseline(
         val label: String, val text: String, val typeface: Int, val size: Float,
-        val seamW: Int, val seamH: Int, val dH: Int,
+        val dH: Int, val seamW: Int? = null, val seamH: Int? = null,
     )
 
     private data class Measured(val b: Baseline, val lw: Int, val lh: Int, val sw: Int, val sh: Int)
 
-    // Non-CJK anchors — signed baseline == legacy (delta 0). Must stay exact across sizes.
+    // Non-CJK anchors — signed baseline == legacy (delta 0). The product contract is parity, not
+    // device-pinned absolute glyph advances, under the any-device policy.
     private val nonCjk = listOf(
-        Baseline("GOLDEN@24", "GOLDEN", TextTypeface.Normal.serializeKey(), 24f, 93, 33, 0),
-        Baseline("MULTILINE@24", "DO NOT\nREDISTRIBUTE", TextTypeface.Normal.serializeKey(), 24f, 161, 61, 0),
-        Baseline("EMOJI@24", "👋 DO NOT REDISTRIBUTE", TextTypeface.Normal.serializeKey(), 24f, 288, 33, 0),
-        Baseline("GOLDEN_BOLD@24", "GOLDEN", TextTypeface.Bold.serializeKey(), 24f, 93, 33, 0),
-        Baseline("GOLDEN_ITALIC@24", "GOLDEN", TextTypeface.Italic.serializeKey(), 24f, 90, 33, 0),
-        Baseline("GOLDEN@12", "GOLDEN", TextTypeface.Normal.serializeKey(), 12f, 46, 17, 0),
-        Baseline("GOLDEN@48", "GOLDEN", TextTypeface.Normal.serializeKey(), 48f, 185, 65, 0),
+        Baseline("GOLDEN@24", "GOLDEN", TextTypeface.Normal.serializeKey(), 24f, dH = 0),
+        Baseline("MULTILINE@24", "DO NOT\nREDISTRIBUTE", TextTypeface.Normal.serializeKey(), 24f, dH = 0),
+        Baseline("EMOJI@24", "👋 DO NOT REDISTRIBUTE", TextTypeface.Normal.serializeKey(), 24f, dH = 0),
+        Baseline("GOLDEN_BOLD@24", "GOLDEN", TextTypeface.Bold.serializeKey(), 24f, dH = 0),
+        Baseline("GOLDEN_ITALIC@24", "GOLDEN", TextTypeface.Italic.serializeKey(), 24f, dH = 0),
+        Baseline("GOLDEN@12", "GOLDEN", TextTypeface.Normal.serializeKey(), 12f, dH = 0),
+        Baseline("GOLDEN@48", "GOLDEN", TextTypeface.Normal.serializeKey(), 48f, dH = 0),
     )
 
-    // CJK — signed baseline accepts the Compose line-height growth (height only; width exact). Pinned to
-    // SM-S906E / API 36. Delta scales with text size AND line count (single-line +1/+2/+5; 2-line +4/+9/+18).
+    // CJK — signed baseline accepts the Compose line-height growth (height only; width exact vs legacy).
+    // Absolutes re-pinned to emulator-5554 / API 36. CJK HEIGHTS match the earlier SM-S906E baseline
+    // exactly (18/35/70/140); only CJK glyph WIDTHS are a few px wider (Noto). Signed ΔH unchanged
+    // (device-independent: single-line +1/+2/+5; 2-line +4/+9/+18).
     private val cjk = listOf(
-        Baseline("CJK_MIX@12", "你好世界 watermark", TextTypeface.Normal.serializeKey(), 12f, 105, 18, 1),
-        Baseline("CJK_SHORT@12", "水印", TextTypeface.Normal.serializeKey(), 12f, 22, 18, 1),
-        Baseline("CJK_MULTILINE@12", "请勿转载\n仅供预览", TextTypeface.Normal.serializeKey(), 12f, 44, 35, 4),
-        Baseline("CJK_MIX@24", "你好世界 watermark", TextTypeface.Normal.serializeKey(), 24f, 212, 35, 2),
-        Baseline("CJK_SHORT@24", "水印", TextTypeface.Normal.serializeKey(), 24f, 46, 35, 2),
-        Baseline("CJK_MULTILINE@24", "请勿转载\n仅供预览", TextTypeface.Normal.serializeKey(), 24f, 92, 70, 9),
-        Baseline("CJK_MIX@48", "你好世界 watermark", TextTypeface.Normal.serializeKey(), 48f, 423, 70, 5),
-        Baseline("CJK_SHORT@48", "水印", TextTypeface.Normal.serializeKey(), 48f, 92, 70, 5),
-        Baseline("CJK_MULTILINE@48", "请勿转载\n仅供预览", TextTypeface.Normal.serializeKey(), 48f, 184, 140, 18),
+        Baseline("CJK_MIX@12", "你好世界 watermark", TextTypeface.Normal.serializeKey(), 12f, dH = 1, seamW = 109, seamH = 18),
+        Baseline("CJK_SHORT@12", "水印", TextTypeface.Normal.serializeKey(), 12f, dH = 1, seamW = 24, seamH = 18),
+        Baseline("CJK_MULTILINE@12", "请勿转载\n仅供预览", TextTypeface.Normal.serializeKey(), 12f, dH = 4, seamW = 48, seamH = 35),
+        Baseline("CJK_MIX@24", "你好世界 watermark", TextTypeface.Normal.serializeKey(), 24f, dH = 2, seamW = 216, seamH = 35),
+        Baseline("CJK_SHORT@24", "水印", TextTypeface.Normal.serializeKey(), 24f, dH = 2, seamW = 48, seamH = 35),
+        Baseline("CJK_MULTILINE@24", "请勿转载\n仅供预览", TextTypeface.Normal.serializeKey(), 24f, dH = 9, seamW = 96, seamH = 70),
+        Baseline("CJK_MIX@48", "你好世界 watermark", TextTypeface.Normal.serializeKey(), 48f, dH = 5, seamW = 431, seamH = 70),
+        Baseline("CJK_SHORT@48", "水印", TextTypeface.Normal.serializeKey(), 48f, dH = 5, seamW = 96, seamH = 70),
+        Baseline(
+            "CJK_MULTILINE@48", "请勿转载\n仅供预览", TextTypeface.Normal.serializeKey(),
+            48f, dH = 18, seamW = 192, seamH = 140,
+        ),
     )
 
     private fun paintFor(b: Baseline): TextPaint {
@@ -86,7 +95,7 @@ class WatermarkCellParityGateTest {
         return TextPaint().applyConfig(imageInfo, config, isScale = false)
     }
 
-    /** Byte-identical to buildTextBitmapShader's measurement. */
+    /** Legacy StaticLayout measurement used as the parity reference for product output. */
     private fun legacyMeasure(paint: TextPaint, text: String): Pair<Int, Int> {
         var maxLineWidth = 0
         text.split("\n").forEach {
@@ -98,7 +107,7 @@ class WatermarkCellParityGateTest {
         return sl.width to sl.height
     }
 
-    /** Candidate seam — delegates to the extracted [WatermarkTextMeasurer]/[TextMeasureEnv]. */
+    /** Product seam — delegates to the extracted [WatermarkTextMeasurer]/[TextMeasureEnv]. */
     private fun seamMeasure(paint: TextPaint, text: String): Pair<Int, Int> {
         val env = androidTextMeasureEnv(InstrumentationRegistry.getInstrumentation().targetContext)
         val size = WatermarkTextMeasurer.measure(env, text, paint.toWatermarkTextStyle())
@@ -109,35 +118,44 @@ class WatermarkCellParityGateTest {
         val paint = paintFor(b)
         val (lw, lh) = legacyMeasure(paint, b.text)
         val (sw, sh) = seamMeasure(paint, b.text)
-        Log.i(tag, "PARITYGATE|${b.label}|legacy=${lw}x${lh}|seam=${sw}x${sh}|d=(${sw - lw},${sh - lh})|signedBaseline=${b.seamW}x${b.seamH}|signedDH=${b.dH}")
+        val signedBaseline = if (b.seamW != null && b.seamH != null) "${b.seamW}x${b.seamH}" else "n/a"
+        Log.i(
+            tag,
+            "PARITYGATE|${b.label}|legacy=${lw}x${lh}|seam=${sw}x${sh}|d=(${sw - lw},${sh - lh})|" +
+                "signedBaseline=$signedBaseline|signedDH=${b.dH}",
+        )
         return Measured(b, lw, lh, sw, sh)
     }
 
-    private fun assertRow(m: Measured) {
+    private fun assertRow(m: Measured, assertAbsoluteBaseline: Boolean) {
         val b = m.b
         // (1) width parity is ALWAYS exact — width never drifts (device-independent).
         assertEquals("width parity [${b.label}]", m.lw, m.sw)
         // (2) signed legacy→seam height delta is exactly the recorded value (device-independent).
         assertEquals("signed height delta [${b.label}]", b.dH, m.sh - m.lh)
-        // (3) signed absolute baseline (API-36 device) — no tolerance (device-pinned).
-        assertEquals("signed baseline width [${b.label}]", b.seamW, m.sw)
-        assertEquals("signed baseline height [${b.label}]", b.seamH, m.sh)
+        if (assertAbsoluteBaseline) {
+            val seamW = requireNotNull(b.seamW) { "missing signed baseline width [${b.label}]" }
+            val seamH = requireNotNull(b.seamH) { "missing signed baseline height [${b.label}]" }
+            // (3) signed absolute baseline (API-36 device) — no tolerance (device-pinned).
+            assertEquals("signed baseline width [${b.label}]", seamW, m.sw)
+            assertEquals("signed baseline height [${b.label}]", seamH, m.sh)
+        }
     }
 
     /** Non-CJK: seam == legacy exactly (signed delta 0) across sizes. */
     @Test
     fun nonCjk_cell_dimensions_match_legacy_exactly() {
         val rows = nonCjk.map { measureAndLog(it) } // log ALL rows before asserting
-        rows.forEach { assertRow(it) }
+        rows.forEach { assertRow(it, assertAbsoluteBaseline = false) }
     }
 
     /**
-     * CJK: width exact; height equals the explicitly signed baseline/delta (candidate — Compose
-     * line-height accepted as the C2b future-renderer baseline, pending sign-off). Green, not hidden.
+     * CJK: width exact; height equals the explicitly signed baseline/delta. Compose line-height is the
+     * accepted S3b/D1 renderer baseline. Green, not hidden.
      */
     @Test
     fun cjk_cell_dimensions_match_signed_baseline() {
         val rows = cjk.map { measureAndLog(it) } // log ALL rows before asserting
-        rows.forEach { assertRow(it) }
+        rows.forEach { assertRow(it, assertAbsoluteBaseline = true) }
     }
 }

app/src/androidTest/java/me/rosuh/easywatermark/render/WatermarkExportInstrumentedGoldenTest.kt

@@ -10,6 +10,7 @@ import android.net.Uri
 import android.text.TextPaint
 import android.util.Log
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import me.rosuh.easywatermark.data.model.ImageInfo
@@ -77,7 +78,11 @@ class WatermarkExportInstrumentedGoldenTest {
         val shader = runBlocking {
             if (spec.text != null) {
                 val paint = TextPaint().applyConfig(imageInfo, config, isScale = false)
-                WaterMarkImageView.buildTextBitmapShader(imageInfo, config, paint, Dispatchers.Unconfined)
+                WaterMarkImageView.buildTextBitmapShader(
+                    imageInfo, config, paint,
+                    androidTextMeasureEnv(InstrumentationRegistry.getInstrumentation().targetContext),
+                    Dispatchers.Unconfined,
+                )
             } else {
                 val src = Bitmap.createBitmap(spec.iconW, spec.iconH, Bitmap.Config.ARGB_8888).apply {
                     eraseColor(Color.WHITE)

app/src/main/java/me/rosuh/easywatermark/render/AndroidTextMeasureEnv.kt

@@ -14,19 +14,21 @@ import androidx.compose.ui.unit.sp
 
 /**
  * C2b text-measurement seam — **Android glue half** (ACSP 20260614-002242, boundary-polished
- * 20260614-080727). NOT product code: `internal`, **not called by any product path**. Builds the
- * platform-neutral [TextMeasureEnv] / drives [WatermarkTextMeasurer] (both in `TextMeasureEnv.kt`) from
- * Android `Context` / `TextPaint`.
+ * 20260614-080727; adopted as **product measurement** in S3b/D1). Builds the platform-neutral
+ * [TextMeasureEnv] / drives [WatermarkTextMeasurer] (both in `TextMeasureEnv.kt`) from Android
+ * `Context` / `TextPaint`. Now called by the product text path
+ * ([me.rosuh.easywatermark.render.WatermarkRenderer.buildTextShader]) via the preview/export call
+ * sites (`WaterMarkImageView`, `MainViewModel.generateImage`); drawing stays legacy `StaticLayout`.
  *
  * These two declarations are the parts that MUST stay Android-side (they touch `Context` and the legacy
  * `TextPaint`); the neutral seam in `TextMeasureEnv.kt` stays free of them so it can move to
  * `:shared/commonMain` unchanged. Behavior is identical to the pre-split file (no logic change).
  */
 
 /**
- * Android bootstrap: build a [TextMeasureEnv] where a [Context] already exists (the future renderer gets
- * this from DI, NOT through `buildTextBitmapShader`/`generateImage`). `Density(1f)` ⇒ image-space
- * (`1.sp == 1px`), the C2b "image-space sizing" direction, decoupled from any view/window density.
+ * Android bootstrap: build a [TextMeasureEnv] at the preview/export boundary where a [Context] already
+ * exists. `Density(1f)` ⇒ image-space (`1.sp == 1px`), the C2b "image-space sizing" direction,
+ * decoupled from any view/window density.
  */
 internal fun androidTextMeasureEnv(context: Context): TextMeasureEnv =
     TextMeasureEnv(

app/src/main/java/me/rosuh/easywatermark/render/TextMeasureEnv.kt

@@ -10,25 +10,30 @@ import androidx.compose.ui.unit.LayoutDirection
 
 /**
  * C2b text-measurement seam — **platform-neutral half** (ACSP 20260614-002242, boundary-polished
- * 20260614-080727). NOT product code: `internal` and **not called by any product path**
- * (`WaterMarkImageView`/`MainViewModel`/`EditorScreen` untouched). Today only the instrumented gate
- * `WatermarkCellParityGateTest` references it (via the Android glue in `AndroidTextMeasureEnv.kt`).
+ * 20260614-080727; adopted as **product measurement** in S3b/D1). Used by the renderer text path
+ * ([WatermarkRenderer.buildTextShader]) for the watermark text-cell box; drawing stays legacy
+ * `StaticLayout`. The instrumented gate `WatermarkCellParityGateTest` pins it against the signed CJK
+ * baseline (non-CJK exact; CJK width exact + signed height delta).
  *
  * This file contains **only platform-neutral, commonMain-ready** declarations — no Android `Context` or
  * `TextPaint`, no `createFontFamilyResolver`/`sp`. It constructs `TextMeasurer` directly (not
  * `@Composable`), so it lifts to `:shared/commonMain` unchanged once `:shared` gains Compose (the
- * `org.jetbrains.compose` ui-text dependency decision flagged in `decisions.md`/ADR-0004 — deliberately
- * out of this slice; the candidate stays app-side and dependency-free).
+ * `org.jetbrains.compose` ui-text dependency decision flagged in `decisions.md`/ADR-0004 — that move is
+ * a later C4-era slice; S3b keeps it app-side, dependency-free).
  *
  * The Android-specific bootstrap (`androidTextMeasureEnv(context)`) and the `TextPaint → TextStyle`
  * adapter (`toWatermarkTextStyle()`) live in the sibling `AndroidTextMeasureEnv.kt`.
  */
 
 /**
- * The minimal text-measurement environment the future renderer needs, as a value object (no `Context`):
+ * The minimal text-measurement environment the renderer needs, as a value object (no `Context`):
  * a [FontFamily.Resolver], a [Density], and a [LayoutDirection]. Platform-neutral / commonMain-ready.
+ *
+ * S3b (D1): **product measurement** — supplied to [WatermarkRenderer.buildTextShader] at the
+ * preview/export call sites (built via `androidTextMeasureEnv(context)`). `public` because it appears
+ * in the renderer's measurement API signature.
  */
-internal data class TextMeasureEnv(
+data class TextMeasureEnv(
     val fontFamilyResolver: FontFamily.Resolver,
     val density: Density,
     val layoutDirection: LayoutDirection = LayoutDirection.Ltr,
@@ -37,6 +42,7 @@ internal data class TextMeasureEnv(
 /**
  * The headless text-cell measurement seam. Platform-neutral: given an injected [TextMeasureEnv] and a
  * [TextStyle], returns the laid-out text size in px — the `StaticLayout.width/height` analogue.
+ * S3b: the renderer's product text-cell measurement.
  */
 internal object WatermarkTextMeasurer {
     fun measure(env: TextMeasureEnv, text: String, style: TextStyle): IntSize =