Expose raster top-4 strokes and add end-to-end release lineage gate

MANIFEST.json

@@ -1,11 +1,11 @@
 {
-    "schema":  "aiflow-hf-research-snapshot-v23",
-    "generated_at":  "2026-07-23T22:50:29.5564804Z",
+    "schema":  "aiflow-hf-research-snapshot-v24",
+    "generated_at":  "2026-07-23T23:05:59.1183762Z",
     "track":  "R_noncommercial_plus_rejected_P_proxy",
     "product_validation":  false,
     "public_release":  true,
     "contains_raw_dataset":  false,
-    "tests":  "334 Python passed + 7 Android passed",
+    "tests":  "348 Python passed + 8 Android passed",
     "retracted_paths":  [
                             "models/auxiliary/boundary_auxiliary_head.pt",
                             "models/auxiliary/seed17/boundary_joint_delta.pt",
@@ -55,8 +55,8 @@
                   },
                   {
                       "path":  "scripts/build_math_ink_06_litert_colab_bundle.py",
-                      "bytes":  6862,
-                      "sha256":  "f008635ab59344005f65f1394f56275e4c92610cd25781a2d95243d060010718"
+                      "bytes":  8003,
+                      "sha256":  "1fb8f75047adb833a36a9354bf6c1f87629053ecd1b487447642b282c9a1f020"
                   },
                   {
                       "path":  "scripts/calibrate_math_ink_06_online_family_fusion.py",
@@ -160,8 +160,8 @@
                   },
                   {
                       "path":  "src/ink06_export.py",
-                      "bytes":  7095,
-                      "sha256":  "8c215219801c7817dbf1fde5890b8c722b4d0cb6eda968714dd0a6fc5f4ab318"
+                      "bytes":  8989,
+                      "sha256":  "544f9d3d8a594e006ac7df25498cd85bd391a56ee3a06f650f2a96469a49312d"
                   },
                   {
                       "path":  "scripts/train_math_ink_06_boundary_behavior_guard.py",
@@ -215,8 +215,8 @@
                   },
                   {
                       "path":  "scripts/export_math_ink_06_p_formula_student.py",
-                      "bytes":  8635,
-                      "sha256":  "4f9083957fa434a23abad9c8a39bd4f9337ce3f8ac9769b1e581bd521d61a997"
+                      "bytes":  8851,
+                      "sha256":  "94c8a12e935471312120649ba239a7d555dc1bbb718cb7fb8a900c5774dee6c7"
                   },
                   {
                       "path":  "scripts/materialize_math_ink_06_p_formula.py",
@@ -240,8 +240,8 @@
                   },
                   {
                       "path":  "scripts/export_math_ink_06_litert.py",
-                      "bytes":  11229,
-                      "sha256":  "6dd7e606c0c8d2f150144ac3e3aa3de527d268be9391fc7fa2a43a3861468a6a"
+                      "bytes":  11912,
+                      "sha256":  "ab69c74d3d6f19d49962b5d75c364a68881cc597e86221507b4f7948a3ea58e7"
                   },
                   {
                       "path":  "scripts/run_math_ink_06_p_formula_release.py",
@@ -285,8 +285,8 @@
                   },
                   {
                       "path":  "android/aiflow-math-ink-runtime/src/test/java/ai/aiflow/mathink/AIFlowMathInkTest.kt",
-                      "bytes":  7268,
-                      "sha256":  "daa54ea4382a11bc4c84fbf05dc99d5ccc0e5f9325336f5a2fc00b271a42c95c"
+                      "bytes":  8609,
+                      "sha256":  "c277bbb2ee20b050fc403ce007bd4ab604d63aae616c67596315412126ecb768"
                   },
                   {
                       "path":  "artifacts/boundary_behavior_guard.joblib",
@@ -305,13 +305,13 @@
                   },
                   {
                       "path":  "android/aiflow-math-ink-runtime/src/main/java/ai/aiflow/mathink/CompiledModelLiteRtSession.kt",
-                      "bytes":  4244,
-                      "sha256":  "5452acda5376977d47b9f3aa1f48e510c181fd2cf3edbd45813e60b8748186ea"
+                      "bytes":  7102,
+                      "sha256":  "f790dc8b79074a9145aa6d541664dae994064c9d5ded54ec808859452ebc7825"
                   },
                   {
                       "path":  "android/aiflow-math-ink-runtime/src/main/java/ai/aiflow/mathink/InkContracts.kt",
-                      "bytes":  3304,
-                      "sha256":  "14e4f1a3f10507abf8fae0e88e692e8ea2ec66454fbe0cce27a8e48bfd766e2f"
+                      "bytes":  5063,
+                      "sha256":  "cd03889545f4ea93eabd75ca86f9b3507f5fbc347f23218cfb47c9ae524adf73"
                   },
                   {
                       "path":  "assets/stroke_encoding.svg",
@@ -320,8 +320,8 @@
                   },
                   {
                       "path":  "colab/aiflow_math_ink_06_litert_bundle.zip.manifest.json",
-                      "bytes":  2978,
-                      "sha256":  "06251288705c15bea4e38285f42b86e9754aa3e7190a030278b36ba69a2d0a78"
+                      "bytes":  3823,
+                      "sha256":  "1afb103d331b37b44ab1fa50927c0a68fcf328a4cd5710c27fe325f9dbebe3b8"
                   },
                   {
                       "path":  "configs/MATH-INK-06-P-FORMULA-v1.json",
@@ -340,13 +340,13 @@
                   },
                   {
                       "path":  "colab/aiflow_math_ink_06_litert_bundle.manifest.json",
-                      "bytes":  2978,
-                      "sha256":  "d6876734bbb23394b40c3b484e2c44d9e06cf3f67de77d3f50205e554b41f758"
+                      "bytes":  3823,
+                      "sha256":  "1afb103d331b37b44ab1fa50927c0a68fcf328a4cd5710c27fe325f9dbebe3b8"
                   },
                   {
                       "path":  "colab/aiflow_math_ink_06_litert_bundle.zip",
-                      "bytes":  17277316,
-                      "sha256":  "5bb4d44d88ebd3a325e35ddfefd1b751c1a09151510e54ad189b5fe18e963701"
+                      "bytes":  17277868,
+                      "sha256":  "1260829d1ba7215e0b857fa51da503ba67f7ffd65f1ba6fb07abd94e13b497bd"
                   },
                   {
                       "path":  "pyproject.snapshot.toml",
@@ -355,8 +355,8 @@
                   },
                   {
                       "path":  "README.md",
-                      "bytes":  22413,
-                      "sha256":  "71a75d7ce8253f336778a9ffa1da58fe4545abcc0a2bc2d018c41f6261ffa071"
+                      "bytes":  22965,
+                      "sha256":  "8219ef8e76e6b69cd7ed5294222633301ef0534373880a88183f43611e185b97"
                   },
                   {
                       "path":  "android/build.gradle.kts",
@@ -395,13 +395,13 @@
                   },
                   {
                       "path":  "android/aiflow-math-ink-runtime/src/main/java/ai/aiflow/mathink/AIFlowMathInk.kt",
-                      "bytes":  5819,
-                      "sha256":  "227370669f6177b4c9a75ec6c610d2cadafbd0288327c5ea853706dece7c39a4"
+                      "bytes":  6421,
+                      "sha256":  "0ad2d9da85a1bc01bb7881625591217df31755247da56b27d7f9a28dd3ce8ab5"
                   },
                   {
                       "path":  "android/README.md",
-                      "bytes":  3167,
-                      "sha256":  "8b2a49f775fba7e8fafdc97ca2abdc7ace2e0da0e3a8a88b46b63f4cfd640ad9"
+                      "bytes":  4176,
+                      "sha256":  "aede1dd3c30bd1c337e0744ae30bb8d477e5b1ea62a742a82b42be8a9960b019"
                   },
                   {
                       "path":  "android/settings.gradle.kts",
@@ -557,6 +557,16 @@
                       "path":  "scripts/summarize_math_ink_06_android_benchmarks.py",
                       "bytes":  5572,
                       "sha256":  "41d5485edb4dadf738fde70d602e4b04f2a53add11729d401711846d3cada906"
+                  },
+                  {
+                      "path":  "scripts/package_math_ink_06_mobile_models.py",
+                      "bytes":  6877,
+                      "sha256":  "5db9b3495977a9316d7b47e666c28d57d019cab0d9e6c2fb1fb10d8928e6b1b3"
+                  },
+                  {
+                      "path":  "scripts/build_math_ink_06_product_release_manifest.py",
+                      "bytes":  6345,
+                      "sha256":  "17e657b607ed6b0b10d8712fd5a9427f3570ea3fd1fe776b42e4868c1332b6a7"
                   }
               ]
 }

README.md

@@ -324,7 +324,9 @@ Student export는 `online adapter → formula adapter → shared classifier →
 
 Android canonicalizer는 Python 대표 4행×19채널과 절대오차 `1e-4` 이내 parity를 통과했다. 최신 standalone LiteRT `CompiledModel` 2.1.6으로 APK asset의 online/raster graph를 직접 실행하며 ML Kit custom model API를 사용하지 않는다.
 
-3-tier benchmark runner는 동일 online/raster SHA-256 쌍의 representative로 warm-up 후 각 100회, PSS, battery charge-counter delta를 측정한다. 개별 hash는 순서가 고정된 bundle SHA-256으로도 묶는다. Python 요약기는 low/mid/high가 정확히 하나씩이고 version·개별 hash·bundle hash가 동일할 때만 online p95 50ms, raster p95 200ms, PSS 100MiB, battery 계측 gate를 AND로 결합한다. Kotlin unit test 7개와 전체 Python 회귀 334개, release AAR build가 통과했다. AAR은 74,915 bytes, SHA-256 `ed38d013e3b2035983d4cdce823df587105b4dbe2bbb6c119c3e7c49cac4125e`이며 모델을 포함하지 않는다. 실제 flatbuffer·기기 benchmark 값은 아직 없다.
+Raster 배포 graph는 exact logits뿐 아니라 top-4 coordinates/state logits/progress/hypothesis scores를 포함한 정확히 5개 output을 요구한다. `recognizeRasterDebug`는 이 값을 로컬에만 노출하고 server payload에는 포함하지 않는다. 실제 seed-17 378-label·76 representative strict export에서 online/raster top-1 76/76, 최대 오차 0.0과 다섯 output shape를 확인했다.
+
+3-tier benchmark runner는 동일 online/raster SHA-256 쌍의 representative로 warm-up 후 각 100회, PSS, battery charge-counter delta를 측정한다. 개별 hash는 순서가 고정된 bundle SHA-256으로도 묶는다. Python 요약기는 low/mid/high가 정확히 하나씩이고 version·개별 hash·bundle hash가 동일할 때만 online p95 50ms, raster p95 200ms, PSS 100MiB, battery 계측 gate를 AND로 결합한다. 최종 product manifest는 P 3-seed, 배포 raster 품질, LiteRT model pair, Android 3-tier의 동일 lineage를 다시 확인한다. Kotlin unit test 8개와 전체 Python 회귀 348개, release AAR build가 통과했다. AAR은 84,436 bytes, SHA-256 `2c65d4af59af1204fad66eff15bec5ef125dfa242da82d05b0e85cf99504c44d`이며 모델을 포함하지 않는다. 실제 flatbuffer·기기 benchmark 값은 아직 없다.
 
 ## 알려진 한계
 

android/README.md

@@ -16,6 +16,9 @@ val recognizer = AIFlowMathInk(session, labels)
 
 val online: SymbolResult = recognizer.recognizeOnline(strokes, InkCanvas(width, height))
 val raster: SymbolResult = recognizer.recognizeRaster(bitmap)
+val debug: RasterDebugResult = recognizer.recognizeRasterDebug(
+    RasterInput(128, 128, normalizedInk),
+)
 ```
 
 `SymbolResult.toServerPayload()`에는 다음 값만 들어간다.
@@ -27,6 +30,8 @@ val raster: SymbolResult = recognizer.recognizeRaster(bitmap)
 
 원본 touch event, canonical tap, raster, virtual stroke는 payload에 들어가지 않는다.
 
+`recognizeRasterDebug`는 같은 로컬 inference에서 top-4의 128×2 좌표, 128×3 pen-state logits, progress, hypothesis log-probability를 반환한다. `RasterDebugResult`에는 server payload 변환 함수가 없으며 일반 `SymbolResult.toServerPayload()`에도 이 값은 포함되지 않는다.
+
 ## 입력 계약
 
 - 원본 touch event는 `AIFlowInkV2.rawStrokes`에 로컬 보존
@@ -56,6 +61,7 @@ gradle :aiflow-math-ink-runtime:assembleRelease
 - gate: online p95 ≤50ms, raster p95 ≤200ms, process PSS ≤100MiB
 - 배터리: charge counter의 측정 가능 여부와 실행 전후 차이를 기록
 - 결과: `AndroidBenchmarkReport.toMap()`을 앱 계층에서 UTF-8 JSON으로 저장
+- raster graph output: exact logits, coordinates, state logits, progress, hypothesis scores의 정확히 5개
 
 세 기기 JSON은 다음 명령으로 합친다.
 
@@ -67,6 +73,17 @@ python scripts/summarize_math_ink_06_android_benchmarks.py `
 
 요약기는 `low`·`mid`·`high`가 정확히 하나씩 존재하고 세 report의 `model_version`, online/raster 개별 SHA-256, bundle SHA-256이 같은지 확인한다. 모든 metric이 세 기기에서 통과해야 `android_release_gate_passed=true`가 된다. 이 값만으로 제품 승인을 만들 수 없도록 `product_validation=false`는 고정한다.
 
+최종 제품 manifest는 P writer/device-disjoint release, 배포 raster 모델에 귀속된 vectorization 지표, LiteRT parity/model bundle, Android 3-tier summary를 모두 결합한다.
+
+```powershell
+python scripts/build_math_ink_06_product_release_manifest.py `
+  --p-release release_report.json `
+  --raster-validation raster-validation.json `
+  --model-bundle mobile-model-bundle.json `
+  --android-summary android-3tier-summary.json `
+  --output product-release.json
+```
+
 공식 참고:
 
 - https://developers.google.com/edge/litert/android

android/aiflow-math-ink-runtime/src/main/java/ai/aiflow/mathink/AIFlowMathInk.kt

@@ -49,6 +49,21 @@ class AIFlowMathInk(
         return result(logits, started)
     }
 
+    /**
+     * 필요 변수: 128×128 raster.
+     * 작동 원리: 동일 inference에서 기호와 top-4 가상 stroke를 가져오되 서버 payload 기능은 제공하지 않는다.
+     */
+    fun recognizeRasterDebug(raster: RasterInput): RasterDebugResult {
+        val started = SystemClock.elapsedRealtimeNanos()
+        val inference = inferenceLock.withLock {
+            session.runRasterDebug(raster.ink)
+        }
+        return RasterDebugResult(
+            symbol = result(inference.exactLogits, started),
+            virtualHypotheses = inference.virtualHypotheses,
+        )
+    }
+
     /** 필요 변수: Android Bitmap. 작동 원리: 실제 ink bbox의 종횡비를 보존해 8px 여백의 128×128로 중앙 배치한다. */
     fun recognizeRaster(bitmap: Bitmap): SymbolResult {
         val sourcePixels = IntArray(bitmap.width * bitmap.height)

android/aiflow-math-ink-runtime/src/main/java/ai/aiflow/mathink/CompiledModelLiteRtSession.kt

@@ -3,6 +3,8 @@ package ai.aiflow.mathink
 import android.content.Context
 import com.google.ai.edge.litert.Accelerator
 import com.google.ai.edge.litert.CompiledModel
+import kotlin.math.exp
+import kotlin.math.ln
 
 /**
  * 필요 변수: online/raster LiteRT flatbuffer·label 수·가속기.
@@ -16,7 +18,10 @@ class CompiledModelLiteRtSession private constructor(
 ) : LiteRtSession {
     init {
         require(exactLabelCount > 0) { "Exact label 수는 양수여야 합니다." }
-        require(online.outputCount >= 1 && raster.outputCount >= 1)
+        require(online.outputCount >= 1) { "Online graph에 exact logit output이 없습니다." }
+        require(raster.outputCount == 5) {
+            "Raster graph는 exact·coordinates·states·progress·scores 5개 output이어야 합니다."
+        }
     }
 
     /** 필요 변수: 128×19 feature. 작동 원리: online graph의 첫 출력 exact logit을 복사해 반환한다. */
@@ -27,8 +32,54 @@ class CompiledModelLiteRtSession private constructor(
 
     /** 필요 변수: 128×128 ink. 작동 원리: raster graph의 첫 출력 exact logit을 복사해 반환한다. */
     override fun runRaster(rasterInk: FloatArray): FloatArray {
+        return runRasterDebug(rasterInk).exactLogits
+    }
+
+    /**
+     * 필요 변수: 128×128 ink.
+     * 작동 원리: 배포 graph의 다섯 출력을 검증하고 top-4 가상 stroke로 분리한다.
+     */
+    override fun runRasterDebug(rasterInk: FloatArray): RasterInference {
         require(rasterInk.size == 128 * 128) { "Raster input은 128×128이어야 합니다." }
-        return raster.run(rasterInk, exactLabelCount)
+        val outputs = raster.runAll(rasterInk)
+        require(outputs[0].size == exactLabelCount) {
+            "Raster exact output ${outputs[0].size}가 label $exactLabelCount 개와 다릅니다."
+        }
+        require(outputs[1].size == 4 * 128 * 2) { "Raster coordinates output shape가 다릅니다." }
+        require(outputs[2].size == 4 * 128 * 3) { "Raster states output shape가 다릅니다." }
+        require(outputs[3].size == 4 * 128) { "Raster progress output shape가 다릅니다." }
+        require(outputs[4].size == 4) { "Raster hypothesis score output shape가 다릅니다." }
+        val logProbabilities = logSoftmax(outputs[4])
+        return RasterInference(
+            exactLogits = outputs[0],
+            virtualHypotheses = List(4) { hypothesis ->
+                VirtualStrokeHypothesis(
+                    points = outputs[1].copyOfRange(
+                        hypothesis * 128 * 2,
+                        (hypothesis + 1) * 128 * 2,
+                    ),
+                    stateLogits = outputs[2].copyOfRange(
+                        hypothesis * 128 * 3,
+                        (hypothesis + 1) * 128 * 3,
+                    ),
+                    progress = outputs[3].copyOfRange(
+                        hypothesis * 128,
+                        (hypothesis + 1) * 128,
+                    ),
+                    logProbability = logProbabilities[hypothesis],
+                )
+            },
+        )
+    }
+
+    /** 필요 변수: 네 개 score logit. 작동 원리: overflow 없이 정규화된 log probability를 계산한다. */
+    private fun logSoftmax(values: FloatArray): FloatArray {
+        require(values.isNotEmpty() && values.all(Float::isFinite))
+        val maximum = values.max()
+        val logDenominator = maximum + ln(
+            values.sumOf { exp((it - maximum).toDouble()) },
+        ).toFloat()
+        return FloatArray(values.size) { index -> values[index] - logDenominator }
     }
 
     /** 필요 변수: 두 CompiledModel. 작동 원리: tensor buffer와 native graph를 모두 명시적으로 해제한다. */
@@ -95,6 +146,14 @@ class CompiledModelLiteRtSession private constructor(
             return exact
         }
 
+        /** 필요 변수: flat input. 작동 원리: 모든 graph output을 한 번 실행한 같은 snapshot에서 복사한다. */
+        fun runAll(input: FloatArray): List<FloatArray> {
+            require(inputs.size == 1) { "AIFlow graph는 단일 input이어야 합니다." }
+            inputs[0].writeFloat(input)
+            model.run(inputs, outputs)
+            return outputs.map { it.readFloat() }
+        }
+
         /** 필요 변수: 모델 buffer. 작동 원리: buffer를 먼저 닫고 native model을 마지막에 해제한다. */
         override fun close() {
             inputs.forEach { it.close() }

android/aiflow-math-ink-runtime/src/main/java/ai/aiflow/mathink/InkContracts.kt

@@ -39,7 +39,7 @@ data class AIFlowInkV2(
     val features: FloatArray,
     val timestampMode: TimestampMode,
     val sourceModality: SourceModality,
-    val virtualHypotheses: List<FloatArray> = emptyList(),
+    val virtualHypotheses: List<VirtualStrokeHypothesis> = emptyList(),
 )
 
 /** 필요 변수: 128×128 grayscale ink. 작동 원리: Bitmap 종속 없이 raster runtime을 시험 가능하게 한다. */
@@ -59,6 +59,38 @@ data class RasterInput(
 
 data class SymbolCandidate(val token: String, val probability: Float)
 
+/** 필요 변수: 128개 좌표·state logit·progress·가설 log probability. 작동 원리: raster 필순 가설을 로컬 debug에서만 보존한다. */
+data class VirtualStrokeHypothesis(
+    val points: FloatArray,
+    val stateLogits: FloatArray,
+    val progress: FloatArray,
+    val logProbability: Float,
+) {
+    init {
+        require(points.size == 128 * 2) { "가상 stroke 좌표는 128×2여야 합니다." }
+        require(stateLogits.size == 128 * 3) { "가상 stroke state는 128×3이어야 합니다." }
+        require(progress.size == 128) { "가상 stroke progress는 128개여야 합니다." }
+        require(
+            points.all(Float::isFinite)
+                && stateLogits.all(Float::isFinite)
+                && progress.all(Float::isFinite)
+                && logProbability.isFinite()
+        ) { "가상 stroke 출력은 모두 유한해야 합니다." }
+    }
+}
+
+/** 필요 변수: raster exact logits·top-4 trajectory. 작동 원리: 일반 인식과 로컬 debug가 같은 inference 결과를 공유한다. */
+data class RasterInference(
+    val exactLogits: FloatArray,
+    val virtualHypotheses: List<VirtualStrokeHypothesis>,
+)
+
+/** 필요 변수: 일반 SymbolResult·가상 stroke. 작동 원리: 서버 payload 기능 없이 로컬 검증 결과만 노출한다. */
+data class RasterDebugResult(
+    val symbol: SymbolResult,
+    val virtualHypotheses: List<VirtualStrokeHypothesis>,
+)
+
 /** 필요 변수: top-k·confidence·버전·지연. 작동 원리: 이미지와 stroke 없이 공개 결과만 반환한다. */
 data class SymbolResult(
     val candidates: List<SymbolCandidate>,
@@ -87,4 +119,10 @@ interface LiteRtSession : AutoCloseable {
 
     fun runOnline(features: FloatArray): FloatArray
     fun runRaster(rasterInk: FloatArray): FloatArray
+
+    /** 필요 변수: raster ink. 작동 원리: 기존 test session은 logits만, 배포 session은 top-4를 함께 반환한다. */
+    fun runRasterDebug(rasterInk: FloatArray): RasterInference = RasterInference(
+        exactLogits = runRaster(rasterInk),
+        virtualHypotheses = emptyList(),
+    )
 }

android/aiflow-math-ink-runtime/src/test/java/ai/aiflow/mathink/AIFlowMathInkTest.kt

@@ -25,6 +25,22 @@ class AIFlowMathInkTest {
             return floatArrayOf(2.0f, 0.0f, 1.0f)
         }
 
+        override fun runRasterDebug(rasterInk: FloatArray): RasterInference {
+            assertEquals(128 * 128, rasterInk.size)
+            rasterCalls += 1
+            return RasterInference(
+                exactLogits = floatArrayOf(2.0f, 0.0f, 1.0f),
+                virtualHypotheses = List(4) { hypothesis ->
+                    VirtualStrokeHypothesis(
+                        points = FloatArray(128 * 2) { hypothesis.toFloat() },
+                        stateLogits = FloatArray(128 * 3),
+                        progress = FloatArray(128) { it / 127.0f },
+                        logProbability = -hypothesis.toFloat(),
+                    )
+                },
+            )
+        }
+
         override fun close() = Unit
     }
 
@@ -131,6 +147,20 @@ class AIFlowMathInkTest {
         assertEquals(1, session.rasterCalls)
     }
 
+    @Test
+    fun rasterDebugReturnsFourLocalHypothesesWithoutServerPayload() {
+        val session = FakeSession()
+        val runtime = AIFlowMathInk(session, listOf("0", "x", "+"), topK = 2)
+        val debug = runtime.recognizeRasterDebug(
+            RasterInput(128, 128, FloatArray(128 * 128)),
+        )
+        assertEquals("0", debug.symbol.candidates.first().token)
+        assertEquals(4, debug.virtualHypotheses.size)
+        assertEquals(128 * 2, debug.virtualHypotheses.first().points.size)
+        assertEquals(1, session.rasterCalls)
+        assertFalse(debug.symbol.toServerPayload().containsKey("virtualHypotheses"))
+    }
+
     @Test
     fun androidBenchmarkUsesNearestRankAndAllReleaseChecks() {
         class Probe : AndroidBenchmarkProbe {

colab/aiflow_math_ink_06_litert_bundle.manifest.json

@@ -1,9 +1,59 @@
 {
   "schema": "aiflow-math-ink-06-litert-colab-bundle-v1",
-  "generated_at": "2026-07-23T20:19:13.374433+00:00",
+  "generated_at": "2026-07-23T23:00:04.923577+00:00",
   "seed": 17,
   "litert_torch_version": "0.9.1",
   "representative_samples": 76,
+  "raster_output_contract": {
+    "outputs": [
+      {
+        "index": 0,
+        "name": "exact_logits",
+        "shape": [
+          1,
+          378
+        ]
+      },
+      {
+        "index": 1,
+        "name": "coordinates",
+        "shape": [
+          1,
+          4,
+          128,
+          2
+        ]
+      },
+      {
+        "index": 2,
+        "name": "state_logits",
+        "shape": [
+          1,
+          4,
+          128,
+          3
+        ]
+      },
+      {
+        "index": 3,
+        "name": "progress",
+        "shape": [
+          1,
+          4,
+          128
+        ]
+      },
+      {
+        "index": 4,
+        "name": "hypothesis_scores",
+        "shape": [
+          1,
+          4
+        ]
+      }
+    ],
+    "direct_raster_label_shortcut": false
+  },
   "files": [
     {
       "path": "pyproject.toml",
@@ -27,13 +77,13 @@
     },
     {
       "path": "src/math_grid_drawer/research/ink06_export.py",
-      "bytes": 4474,
-      "sha256": "37c67827f1c39df9cb0f6c45f782c58a2d1bdf5190e51070de817d1ba2693b67"
+      "bytes": 8989,
+      "sha256": "544f9d3d8a594e006ac7df25498cd85bd391a56ee3a06f650f2a96469a49312d"
     },
     {
       "path": "src/math_grid_drawer/research/math_ink_06.py",
-      "bytes": 58690,
-      "sha256": "657a720f32bfe8548ec859986bc3b6bcafbf3ec70f0abfdbf50127946c655052"
+      "bytes": 59569,
+      "sha256": "1972ad82e7694e5c3c64776ef90568473bfdaf40b7ab5c46c973e482b98e48ad"
     },
     {
       "path": "src/math_grid_drawer/research/raster_skeleton06.py",
@@ -52,8 +102,8 @@
     },
     {
       "path": "scripts/export_math_ink_06_litert.py",
-      "bytes": 11027,
-      "sha256": "68510ea84f778bc415c3b5b29e3445cd0c5102a5febb1bb126c92262c75ccebb"
+      "bytes": 11239,
+      "sha256": "d40a8464491721712d712d5476fa2cb26f3d9886a8f05e9ce46f3c281ec14e50"
     },
     {
       "path": "artifacts/base_378.pt",
@@ -72,9 +122,9 @@
     }
   ],
   "product_validation": false,
-  "bundle": "research\\runs\\math_ink_06_litert_colab_20260724\\aiflow_math_ink_06_litert_bundle.zip",
-  "bundle_bytes": 17276876,
-  "bundle_sha256": "d5357732c9f1654d65664e3fe23acab88a7374e88e3f2bd5b60ab46120aefc47",
+  "bundle": "research\\runs\\math_ink_06_litert_colab_debug5_20260724\\aiflow_math_ink_06_litert_bundle.zip",
+  "bundle_bytes": 17277868,
+  "bundle_sha256": "1260829d1ba7215e0b857fa51da503ba67f7ffd65f1ba6fb07abd94e13b497bd",
   "verification": {
     "schema": "aiflow-math-ink-06-litert-colab-bundle-v1",
     "files": 13,

colab/aiflow_math_ink_06_litert_bundle.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5bb4d44d88ebd3a325e35ddfefd1b751c1a09151510e54ad189b5fe18e963701
-size 17277316
+oid sha256:1260829d1ba7215e0b857fa51da503ba67f7ffd65f1ba6fb07abd94e13b497bd
+size 17277868

colab/aiflow_math_ink_06_litert_bundle.zip.manifest.json

@@ -1,9 +1,59 @@
 {
   "schema": "aiflow-math-ink-06-litert-colab-bundle-v1",
-  "generated_at": "2026-07-23T20:42:31.265188+00:00",
+  "generated_at": "2026-07-23T23:00:04.923577+00:00",
   "seed": 17,
   "litert_torch_version": "0.9.1",
   "representative_samples": 76,
+  "raster_output_contract": {
+    "outputs": [
+      {
+        "index": 0,
+        "name": "exact_logits",
+        "shape": [
+          1,
+          378
+        ]
+      },
+      {
+        "index": 1,
+        "name": "coordinates",
+        "shape": [
+          1,
+          4,
+          128,
+          2
+        ]
+      },
+      {
+        "index": 2,
+        "name": "state_logits",
+        "shape": [
+          1,
+          4,
+          128,
+          3
+        ]
+      },
+      {
+        "index": 3,
+        "name": "progress",
+        "shape": [
+          1,
+          4,
+          128
+        ]
+      },
+      {
+        "index": 4,
+        "name": "hypothesis_scores",
+        "shape": [
+          1,
+          4
+        ]
+      }
+    ],
+    "direct_raster_label_shortcut": false
+  },
   "files": [
     {
       "path": "pyproject.toml",
@@ -27,8 +77,8 @@
     },
     {
       "path": "src/math_grid_drawer/research/ink06_export.py",
-      "bytes": 5348,
-      "sha256": "b9a3e73bcaa19e0a868b3daad533cc3a3b784a4b99d447c2d51f9b74644554a1"
+      "bytes": 8989,
+      "sha256": "544f9d3d8a594e006ac7df25498cd85bd391a56ee3a06f650f2a96469a49312d"
     },
     {
       "path": "src/math_grid_drawer/research/math_ink_06.py",
@@ -52,8 +102,8 @@
     },
     {
       "path": "scripts/export_math_ink_06_litert.py",
-      "bytes": 11229,
-      "sha256": "6dd7e606c0c8d2f150144ac3e3aa3de527d268be9391fc7fa2a43a3861468a6a"
+      "bytes": 11239,
+      "sha256": "d40a8464491721712d712d5476fa2cb26f3d9886a8f05e9ce46f3c281ec14e50"
     },
     {
       "path": "artifacts/base_378.pt",
@@ -72,9 +122,9 @@
     }
   ],
   "product_validation": false,
-  "bundle": "research\\runs\\math_ink_06_litert_colab_20260724\\aiflow_math_ink_06_litert_bundle.zip",
-  "bundle_bytes": 17277316,
-  "bundle_sha256": "5bb4d44d88ebd3a325e35ddfefd1b751c1a09151510e54ad189b5fe18e963701",
+  "bundle": "research\\runs\\math_ink_06_litert_colab_debug5_20260724\\aiflow_math_ink_06_litert_bundle.zip",
+  "bundle_bytes": 17277868,
+  "bundle_sha256": "1260829d1ba7215e0b857fa51da503ba67f7ffd65f1ba6fb07abd94e13b497bd",
   "verification": {
     "schema": "aiflow-math-ink-06-litert-colab-bundle-v1",
     "files": 13,

scripts/build_math_ink_06_litert_colab_bundle.py

@@ -68,6 +68,16 @@ def build_litert_colab_bundle06(
         "seed": 17,
         "litert_torch_version": "0.9.1",
         "representative_samples": 76,
+        "raster_output_contract": {
+            "outputs": [
+                {"index": 0, "name": "exact_logits", "shape": [1, 378]},
+                {"index": 1, "name": "coordinates", "shape": [1, 4, 128, 2]},
+                {"index": 2, "name": "state_logits", "shape": [1, 4, 128, 3]},
+                {"index": 3, "name": "progress", "shape": [1, 4, 128]},
+                {"index": 4, "name": "hypothesis_scores", "shape": [1, 4]},
+            ],
+            "direct_raster_label_shortcut": False,
+        },
         "files": entries,
         "product_validation": False,
     }
@@ -99,6 +109,21 @@ def verify_litert_colab_bundle06(bundle_path: Path) -> dict:
     failures = []
     with ZipFile(bundle_path) as bundle:
         manifest = json.loads(bundle.read(MANIFEST_NAME_06).decode("utf-8"))
+        contract = manifest.get("raster_output_contract") or {}
+        output_names = [
+            str(row.get("name") or "")
+            for row in contract.get("outputs", [])
+        ]
+        if output_names != [
+            "exact_logits",
+            "coordinates",
+            "state_logits",
+            "progress",
+            "hypothesis_scores",
+        ]:
+            failures.append({"path": MANIFEST_NAME_06, "reason": "raster_output_contract"})
+        if contract.get("direct_raster_label_shortcut") is not False:
+            failures.append({"path": MANIFEST_NAME_06, "reason": "raster_shortcut_contract"})
         names = set(bundle.namelist())
         for row in manifest["files"]:
             name = str(row["path"])

scripts/build_math_ink_06_product_release_manifest.py

@@ -0,0 +1,132 @@
+"""P 성능·raster 품질·LiteRT 모델 쌍·Android 3-tier를 최종 제품 gate로 결합한다."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import re
+from typing import Any
+
+
+def build_product_release_manifest06(
+    *,
+    p_release: dict[str, Any],
+    raster_validation: dict[str, Any],
+    model_bundle: dict[str, Any],
+    android_summary: dict[str, Any],
+) -> dict[str, Any]:
+    """필요 변수: 네 독립 release 증거. 작동 원리: 동일 data/model lineage와 모든 hard gate를 AND로 결합한다."""
+
+    if p_release.get("schema") != "aiflow-math-ink-06-p-formula-release-plan-v1":
+        raise ValueError("지원하지 않는 P release report입니다.")
+    if (
+        p_release.get("completed") is not True
+        or p_release.get("torch_export_gate_passed") is not True
+    ):
+        raise ValueError("P writer/device-disjoint 3-seed release가 완료되지 않았습니다.")
+    if raster_validation.get("schema") != "aiflow-math-ink-06-raster-release-validation-v1":
+        raise ValueError("지원하지 않는 raster validation report입니다.")
+    if set(int(seed) for seed in raster_validation.get("seeds", [])) != {17, 31, 47}:
+        raise ValueError("Raster validation은 seed 17·31·47을 모두 포함해야 합니다.")
+    metrics = raster_validation.get("metrics") or {}
+    metric_checks = {
+        "downstream_label_preservation": float(
+            metrics.get("downstream_label_preservation", 0.0),
+        ) >= 0.90,
+        "skeleton_dice": float(metrics.get("skeleton_dice", 0.0)) >= 0.90,
+        "chamfer": float(metrics.get("chamfer_px", float("inf"))) <= 1.50,
+    }
+    if raster_validation.get("gate_passed") is not True or not all(metric_checks.values()):
+        raise ValueError("Raster vectorization release gate가 통과하지 않았습니다.")
+    if model_bundle.get("schema") != "aiflow-math-ink-06-mobile-model-bundle-v1":
+        raise ValueError("지원하지 않는 mobile model bundle입니다.")
+    if model_bundle.get("package_gate_passed") is not True:
+        raise ValueError("Mobile model bundle gate가 통과하지 않았습니다.")
+    if android_summary.get("schema") != "aiflow-math-ink-06-android-3tier-summary-v1":
+        raise ValueError("지원하지 않는 Android summary입니다.")
+    if (
+        android_summary.get("android_hardware_validation") is not True
+        or android_summary.get("android_release_gate_passed") is not True
+    ):
+        raise ValueError("Android low/mid/high gate가 통과하지 않았습니다.")
+    for evidence in (p_release, raster_validation, model_bundle, android_summary):
+        if evidence.get("product_validation") is not False:
+            raise ValueError("하위 증거가 product_validation을 직접 선언할 수 없습니다.")
+    data_hashes = {
+        str(p_release.get("data_sha256") or ""),
+        str(model_bundle.get("data_sha256") or ""),
+    }
+    if (
+        len(data_hashes) != 1
+        or re.fullmatch(r"[0-9a-f]{64}", next(iter(data_hashes))) is None
+    ):
+        raise ValueError("P release와 mobile bundle의 data SHA-256이 같아야 합니다.")
+    artifacts = model_bundle.get("artifacts") or {}
+    online_hash = str((artifacts.get("online") or {}).get("sha256") or "")
+    raster_hash = str((artifacts.get("raster") or {}).get("sha256") or "")
+    bundle_hash = str(model_bundle.get("model_bundle_sha256") or "")
+    if raster_validation.get("raster_model_sha256") != raster_hash:
+        raise ValueError("Raster validation이 실제 배포 raster model과 다릅니다.")
+    if (
+        android_summary.get("online_model_sha256") != online_hash
+        or android_summary.get("raster_model_sha256") != raster_hash
+        or android_summary.get("model_bundle_sha256") != bundle_hash
+    ):
+        raise ValueError("Android 측정 모델과 배포 bundle이 다릅니다.")
+    if android_summary.get("model_version") != model_bundle.get("model_version"):
+        raise ValueError("Android 측정 model version과 bundle version이 다릅니다.")
+    return {
+        "schema": "aiflow-math-ink-06-product-release-v1",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "model_version": model_bundle["model_version"],
+        "data_sha256": next(iter(data_hashes)),
+        "online_model_sha256": online_hash,
+        "raster_model_sha256": raster_hash,
+        "model_bundle_sha256": bundle_hash,
+        "checks": {
+            "p_writer_device_disjoint": True,
+            "raster_downstream_label_preservation": metric_checks[
+                "downstream_label_preservation"
+            ],
+            "raster_skeleton_dice": metric_checks["skeleton_dice"],
+            "raster_chamfer": metric_checks["chamfer"],
+            "litert_parity_and_size": True,
+            "android_low_mid_high": True,
+            "same_data_and_model_lineage": True,
+        },
+        "product_validation": True,
+        "release_gate_passed": True,
+    }
+
+
+def main() -> None:
+    """필요 변수: 네 UTF-8 JSON·출력. 작동 원리: 최종 release manifest를 원자적으로 기록한다."""
+
+    parser = argparse.ArgumentParser(description="Build Math Ink 0.6 product release")
+    parser.add_argument("--p-release", type=Path, required=True)
+    parser.add_argument("--raster-validation", type=Path, required=True)
+    parser.add_argument("--model-bundle", type=Path, required=True)
+    parser.add_argument("--android-summary", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    load = lambda path: json.loads(path.read_text(encoding="utf-8"))
+    result = build_product_release_manifest06(
+        p_release=load(args.p_release),
+        raster_validation=load(args.raster_validation),
+        model_bundle=load(args.model_bundle),
+        android_summary=load(args.android_summary),
+    )
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    temporary = args.output.with_suffix(args.output.suffix + ".part")
+    temporary.write_text(
+        json.dumps(result, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    temporary.replace(args.output)
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/export_math_ink_06_litert.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+from hashlib import sha256
 import importlib.util
 import json
 from pathlib import Path
@@ -18,12 +19,23 @@ if str(SOURCE_ROOT) not in sys.path:
 
 from math_grid_drawer.research.ink06_canonical import canonicalize_ink06, render_canonical_ink
 from math_grid_drawer.research.ink06_export import (
-    OnlineExportWrapper06, RasterExportWrapper06, exported_equivalence06,
+    OnlineExportWrapper06, RasterDebugExportWrapper06, exported_equivalence06,
 )
 from math_grid_drawer.research.math_ink_06 import MathInk06Engine
 from math_grid_drawer.research.skeleton_adapter06 import DualModalityTrajectoryAdapter06
 
 
+def _vocabulary_sha25606(labels: tuple[str, ...] | list[str]) -> str:
+    """필요 변수: 순서가 고정된 exact labels. 작동 원리: Android label table과 graph의 동일성을 위한 SHA-256을 만든다."""
+
+    payload = json.dumps(
+        list(labels),
+        ensure_ascii=False,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    return sha256(payload).hexdigest()
+
+
 def _representative_inputs(baseline_report: Path, data_path: Path) -> tuple[list[tuple[torch.Tensor, ...]], list[tuple[torch.Tensor, ...]]]:
     """필요 변수: strict baseline·HWRT JSONL. 작동 원리: 고정 76개를 128×19와 128×128 대표 입력으로 재구성한다."""
 
@@ -170,7 +182,7 @@ def main() -> None:
         family_weight=engine.online_family_fusion_weight,
         exact_family_index=engine.exact_family_index,
     ).eval()
-    raster = RasterExportWrapper06(
+    raster = RasterDebugExportWrapper06(
         engine.model, adapter=raster_adapter,
         fusion_mode=str(fusion["mode"]), score_weight=float(fusion["score_weight"]),
     ).eval()
@@ -190,9 +202,14 @@ def main() -> None:
     _save_exported_program06(online_export, online_path)
     _save_exported_program06(raster_export, raster_path)
     report = {
+        "schema": "aiflow-math-ink-06-dual-export-v1",
         "checkpoint": str(args.checkpoint), "adapter_checkpoint": str(args.adapter_checkpoint),
         "adapter_architecture": str(adapter_payload["adapter_architecture"]),
         "shared_state_applied": bool(adapter_payload.get("shared_state_dict")),
+        "model_version": engine.model_version,
+        "exact_label_count": len(engine.labels),
+        "vocabulary_sha256": _vocabulary_sha25606(list(engine.labels)),
+        "raster_output_count": 5,
         "online_family_fusion_weight": engine.online_family_fusion_weight,
         "torch_version": torch.__version__,
         "torch_export": {

scripts/export_math_ink_06_p_formula_student.py

@@ -29,7 +29,11 @@ from math_grid_drawer.research.skeleton_adapter06 import (
     DualModalityTrajectoryAdapter06,
     SkeletonTrajectoryAdapter06,
 )
-from scripts.export_math_ink_06_litert import _convert_litert, _save_exported_program06
+from scripts.export_math_ink_06_litert import (
+    _convert_litert,
+    _save_exported_program06,
+    _vocabulary_sha25606,
+)
 from scripts.train_math_ink_06_p_formula_adapter import _file_sha25606
 
 
@@ -154,6 +158,9 @@ def main() -> None:
     size_gate = program_path.stat().st_size <= MAXIMUM_MODEL_BYTES06
     report: dict[str, Any] = {
         "schema": "aiflow-math-ink-06-p-formula-student-export-v1",
+        "model_version": f"{engine.model_version}+p-formula-student",
+        "exact_label_count": len(labels),
+        "vocabulary_sha256": _vocabulary_sha25606(list(labels)),
         "student_checkpoint": str(args.student_checkpoint),
         "data_sha256": data_sha256,
         "teacher_seeds": [17, 31, 47],

scripts/package_math_ink_06_mobile_models.py

@@ -0,0 +1,163 @@
+"""통과한 online/raster LiteRT를 하나의 Android 모델 쌍으로 묶는다."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+from hashlib import sha256
+import json
+from pathlib import Path
+import re
+from typing import Any
+
+
+MAXIMUM_BUNDLE_BYTES06 = 25 * 1024 * 1024
+
+
+def _file_sha256_06(path: Path) -> str:
+    """필요 변수: 모델 파일. 작동 원리: 파일 전체를 streaming SHA-256으로 식별한다."""
+
+    digest = sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def model_bundle_sha25606(online_sha256: str, raster_sha256: str) -> str:
+    """필요 변수: online/raster hash. 작동 원리: Android와 동일한 ordered bundle 지문을 만든다."""
+
+    payload = f"online:{online_sha256}\nraster:{raster_sha256}\n".encode("utf-8")
+    return sha256(payload).hexdigest()
+
+
+def _require_litert_row06(
+    report: dict[str, Any],
+    *,
+    branch: str,
+) -> dict[str, Any]:
+    """필요 변수: export report·branch. 작동 원리: 변환·parity gate가 모두 통과한 LiteRT 행만 반환한다."""
+
+    litert = report.get("litert") or {}
+    row = litert if branch == "online" and "online" not in litert else litert.get(branch)
+    if not isinstance(row, dict):
+        raise ValueError(f"{branch} LiteRT 결과가 없습니다.")
+    if row.get("converted") is not True or row.get("gate_passed") is not True:
+        raise ValueError(f"{branch} LiteRT 변환/parity gate가 통과하지 않았습니다.")
+    if float(row.get("top1_agreement", 0.0)) != 1.0:
+        raise ValueError(f"{branch} LiteRT top-1 agreement가 100%가 아닙니다.")
+    if float(row.get("max_absolute_logit_error", float("inf"))) > 0.02:
+        raise ValueError(f"{branch} LiteRT logit 오차가 0.02를 초과했습니다.")
+    return row
+
+
+def package_mobile_models06(
+    *,
+    online_report: dict[str, Any],
+    raster_report: dict[str, Any],
+    online_model: Path,
+    raster_model: Path,
+) -> dict[str, Any]:
+    """필요 변수: 두 export report와 실제 flatbuffer. 작동 원리: vocabulary·parity·파일을 검증해 불변 모델 쌍을 만든다."""
+
+    if online_report.get("schema") != "aiflow-math-ink-06-p-formula-student-export-v1":
+        raise ValueError("Online은 통과한 P Formula student export여야 합니다.")
+    if raster_report.get("schema") != "aiflow-math-ink-06-dual-export-v1":
+        raise ValueError("Raster는 0.6 dual export여야 합니다.")
+    if online_report.get("torch_export_gate_passed") is not True:
+        raise ValueError("Online torch.export gate가 통과하지 않았습니다.")
+    if raster_report.get("torch_export_gate_passed") is not True:
+        raise ValueError("Raster torch.export gate가 통과하지 않았습니다.")
+    if int(raster_report.get("raster_output_count", 0)) != 5:
+        raise ValueError("Raster graph는 top-4 debug를 포함한 5-output이어야 합니다.")
+    counts = {
+        int(online_report.get("exact_label_count", 0)),
+        int(raster_report.get("exact_label_count", 0)),
+    }
+    vocabularies = {
+        str(online_report.get("vocabulary_sha256") or ""),
+        str(raster_report.get("vocabulary_sha256") or ""),
+    }
+    if counts != {378}:
+        raise ValueError("Online/raster 모두 378 exact labels여야 합니다.")
+    if (
+        len(vocabularies) != 1
+        or re.fullmatch(r"[0-9a-f]{64}", next(iter(vocabularies))) is None
+    ):
+        raise ValueError("Online/raster vocabulary SHA-256이 같아야 합니다.")
+    online_row = _require_litert_row06(online_report, branch="online")
+    raster_row = _require_litert_row06(raster_report, branch="raster")
+    artifacts = {}
+    for name, path, row in (
+        ("online", online_model, online_row),
+        ("raster", raster_model, raster_row),
+    ):
+        if not path.is_file():
+            raise FileNotFoundError(f"{name} LiteRT 파일이 없습니다: {path}")
+        size = path.stat().st_size
+        if Path(str(row.get("path") or "")).name != path.name:
+            raise ValueError(f"{name} report path와 실제 파일명이 다릅니다.")
+        if int(row.get("bytes", -1)) != size:
+            raise ValueError(f"{name} report byte 수와 실제 파일이 다릅니다.")
+        artifacts[name] = {
+            "path": path.name,
+            "bytes": size,
+            "sha256": _file_sha256_06(path),
+        }
+    total_bytes = sum(row["bytes"] for row in artifacts.values())
+    size_gate = total_bytes <= MAXIMUM_BUNDLE_BYTES06
+    bundle_hash = model_bundle_sha25606(
+        artifacts["online"]["sha256"],
+        artifacts["raster"]["sha256"],
+    )
+    return {
+        "schema": "aiflow-math-ink-06-mobile-model-bundle-v1",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "model_version": str(online_report["model_version"]),
+        "data_sha256": str(online_report.get("data_sha256") or ""),
+        "exact_label_count": 378,
+        "vocabulary_sha256": next(iter(vocabularies)),
+        "artifacts": artifacts,
+        "model_bundle_sha256": bundle_hash,
+        "total_bytes": total_bytes,
+        "maximum_bundle_bytes": MAXIMUM_BUNDLE_BYTES06,
+        "checks": {
+            "online_litert_parity": True,
+            "raster_litert_parity": True,
+            "raster_five_outputs": True,
+            "same_vocabulary": True,
+            "size": size_gate,
+        },
+        "package_gate_passed": size_gate,
+        "product_validation": False,
+    }
+
+
+def main() -> None:
+    """필요 변수: report·flatbuffer·출력. 작동 원리: 검증된 UTF-8 bundle manifest를 원자적으로 기록한다."""
+
+    parser = argparse.ArgumentParser(description="Package Math Ink 0.6 mobile models")
+    parser.add_argument("--online-report", type=Path, required=True)
+    parser.add_argument("--raster-report", type=Path, required=True)
+    parser.add_argument("--online-model", type=Path, required=True)
+    parser.add_argument("--raster-model", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    result = package_mobile_models06(
+        online_report=json.loads(args.online_report.read_text(encoding="utf-8")),
+        raster_report=json.loads(args.raster_report.read_text(encoding="utf-8")),
+        online_model=args.online_model,
+        raster_model=args.raster_model,
+    )
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    temporary = args.output.with_suffix(args.output.suffix + ".part")
+    temporary.write_text(
+        json.dumps(result, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    temporary.replace(args.output)
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

src/ink06_export.py

@@ -126,6 +126,50 @@ class RasterExportWrapper06(nn.Module):
         return fused
 
 
+class RasterDebugExportWrapper06(RasterExportWrapper06):
+    """필요 변수: raster model·adapter·fusion. 작동 원리: logits와 top-4 가상 stroke 검증 출력을 함께 고정한다."""
+
+    def forward(
+        self,
+        raster: Tensor,
+    ) -> tuple[Tensor, Tensor, Tensor, Tensor, Tensor]:
+        """필요 변수: B×1×128×128 raster. 작동 원리: direct shortcut 없이 분류하고 trajectory 원시 출력을 보존한다."""
+
+        coordinates, states, progress, hypothesis_scores = (
+            self.model.decode_raster_trajectories(raster)
+        )
+        features = virtual_features06(
+            coordinates,
+            states,
+            None if self.model.raster_architecture == "spatial_flat_v1" else progress,
+            contract=self.model.virtual_contract,
+        )
+        batch, hypotheses, steps, channels = features.shape
+        if self.model.use_virtual_adapter:
+            raw_features = features
+            internal = self.model.virtual_adapter(
+                features.reshape(batch * hypotheses, steps, channels),
+            ).reshape(batch, hypotheses, steps, channels)
+            features = raw_features + self.model.virtual_adapter_weight * (
+                internal - raw_features
+            )
+        flat_features = self.adapter(
+            features.reshape(batch * hypotheses, steps, channels),
+        )
+        exact, family = self.model.classify_trajectory(flat_features)
+        output = {
+            "hypothesis_scores": hypothesis_scores,
+            "exact_logits": exact.reshape(batch, hypotheses, -1),
+            "family_logits": family.reshape(batch, hypotheses, -1),
+        }
+        fused, _selected = fuse_raster_logits06(
+            output,
+            mode=self.fusion_mode,
+            score_weight=self.score_weight,
+        )
+        return fused, coordinates, states, progress, hypothesis_scores
+
+
 def exported_equivalence06(
     eager: nn.Module, exported: torch.export.ExportedProgram, inputs: Iterable[tuple[Tensor, ...]],
 ) -> dict[str, float | int | bool]: