Remove the value blob; fixed-size arrays cross as Kotlin primitive arrays

examples/covertest-kotlin/build.rs

@@ -21,7 +21,6 @@
 //! | `DataClassDecl::jobject_input()`     | `ObjectBoundary` (127 `Long` leaves plus JNI infrastructure exceed the JVM's 255-slot method limit) |
 //! | `PtrClassDecl`                       | `Storage` / `Summary` / `StorageError` / `Archive` / handlers |
 //! | `EnumClassDecl`                      | `Priority` |
-//! | `ValueClassDecl`                     | `Stamp` (+ `Vec<Stamp>` → `List<ByteArray>`) |
 //! | `convert!` + chained source streams   | `Millis` ⇄ `Long` via `covertest-helpers` fns |
 //! | `Source::builder().crate_name()`      | the helpers dep is RENAMED to `cov_helpers` in Cargo.toml |
 //! | `convert!` `.input(from!)`/`.output(into!)` | `Celsius` ⇄ `Int` via `From`/`Into` impls |
@@ -54,7 +53,7 @@
 //! | binding-local fn `fun!(crate::…)` `.sig(sig!)` as free fn | `describeSummary` ← `crate::summary_describe` |
 //! | binding-local fn as `.method()` / `.constructor()` | `Summary.mean()` ← `crate::summary_mean` (NO `.name` — derived by the strip hook); `Summary.fromMean` ← `crate::summary_from_mean` (FALLIBLE — sig `Result` → `onError`) |
 //! | `Result<_, E>` → typed domain `onError` | `storage_try_with_label` |
-//! | two-caller split (#45): `onBindingError` + `onError` on one fallible wrapper | `storage_try_from_stamp` (malformed `Stamp` → binding; bad `secs` → domain) |
+//! | two-caller split (#45): `onBindingError` + `onError` on one fallible wrapper | `storage_try_from_stamp` (wrong-length `tag` → binding; bad `secs` → domain) |
 //! | fixed-width unsigned scalars (#108) | `Unsigned` + direct/optional/callback/collection max-value round trips |
 //! | `Option<T>`                          | `Option<Payload>` (in + out) / `Option<Vec>` / `Option<i64>` / `Option<enum>` (param + return + field) |
 //! | non-null enum field under nullable-context (#144) | `Option<CacheConfig>` → nested `RepliesConfig.priority` (single Elvis default) |
@@ -66,7 +65,7 @@
 //! | N-ary sorted handle locking          | `storage_total_len` (3 handles) + a 4-thread smoke |
 //! | `Vec<String>` return                 | `storage_labels` (single-leaf string fold) |
 //! | `String` return                      | `string_new` |
-//! | binding-error channel (`JniErrorHandler`) | malformed `Stamp` bytes (value-blob length guard) |
+//! | binding-error channel (`JniErrorHandler`) | wrong-length `[u8; 2]` (fixed-size array length guard) |
 //! | callback no-throw contract           | a throwing `PayloadCallback` (described + cleared per upcall) |
 //! | `data_class` instance member          | `Payload.labelLen()` (receiver crosses as `this` field leaves) |
 //! | `JniGen::ignore` (exact)              | `string_len` / `storage_put_by_read_and_update` (acknowledged-unbound, no skip warnings) |
@@ -99,7 +98,7 @@
 use prebindgen::{
     constant, convert, core::Registry, data_class, enum_class, expand_param, expand_return, expr,
     from, fun, into, lang::JniGen, matching, package, path, ptr_class, sealed_class, sig, try_from,
-    ty, value_class, variant,
+    ty, variant,
 };
 
 fn strip_flat_class_prefix(class: &str, name: &str) -> String {
@@ -286,14 +285,22 @@ fn main() {
                 // Fixed-width unsigned mappings: Int / Long widening plus
                 // ULong over a raw jlong bit pattern.
                 .class(data_class!(Unsigned))
-                // `Stamp` as a `@JvmInline value class` over its raw bytes; its readers
-                // become instance methods (`secs()` / `nanos()`), and `Vec<Stamp>`
-                // surfaces as `List<ByteArray>`.
+                // `Stamp` is a small `Copy` struct of two scalars, so it crosses
+                // as its FIELDS — no array, no raw-memory image. Its readers stay
+                // instance methods (`secs()` / `nanos()`) whose receiver crosses
+                // as those field leaves, and `Vec<Stamp>` surfaces as
+                // `List<Stamp>`.
                 .class(
-                    value_class!(Stamp)
+                    data_class!(Stamp)
                         .method(fun!(stamp_secs))
                         .method(fun!(stamp_nanos)),
-                ),
+                )
+                // `BlobValue` is the array-backed EQUALITY probe: a raw-bytes
+                // field beside a scalar, plus a nested data class. Both compare
+                // by identity in Kotlin unless the binding says otherwise.
+                .class(data_class!(BlobValue).jobject_input())
+                // Fixed-size arrays of every JNI-primitive element.
+                .class(data_class!(Arrays)),
         )
         // ── Subpackage `errors`: the Result error channel ───────────────────
         .package(package!("errors").class(
@@ -501,6 +508,9 @@ fn main() {
                 .fun(fun!(unsigned_data_maybe))
                 .fun(fun!(unsigned_emit))
                 .fun(fun!(unsigned_series))
+                .fun(fun!(blob_value_new))
+                .fun(fun!(blob_value_echo))
+                .fun(fun!(arrays_echo))
                 .fun(fun!(duration_optional))
                 .fun(fun!(duration_boundary_echo))
                 // The converted analogue of `unsigned_emit`: a whole-value

examples/covertest-kotlin/kotlin/REPORT.md

@@ -57,6 +57,12 @@ Base package: `io.prebindgen.covertest`
 - `archive_reading_maybe` — `fun archiveReadingMaybe(a: SummaryVault, onError: JniErrorHandler<Reading?>): Reading?`
   - shaped by: return `Reading` decomposed → [tag, exact_v0, range_low, range_high, tagged_v0, tagged_v1, companion_v0] (Callback delivery)
 - `archive_set_reading` — `fun archiveSetReading(a: SummaryVault, which: Int, onError: JniErrorHandler<Unit>)`
+- `arrays_echo` — `fun arraysEcho(a: Arrays, onError: JniErrorHandler<Arrays>): Arrays`
+  - shaped by: return `Arrays` decomposed → [bytes, shorts, ints, longs, doubles, flags, raw] (Callback delivery)
+- `blob_value_echo` — `fun blobValueEcho(value: BlobValue, onError: JniErrorHandler<BlobValue>): BlobValue`
+  - shaped by: return `BlobValue` decomposed → [stamp__secs, stamp__nanos, id, chunks] (Callback delivery)
+- `blob_value_new` — `fun blobValueNew(secs: Long, id: ByteArray, chunks: List<ByteArray>, onError: JniErrorHandler<BlobValue>): BlobValue`
+  - shaped by: return `BlobValue` decomposed → [stamp__secs, stamp__nanos, id, chunks] (Callback delivery)
 - `cache_config_weight` — `fun cacheConfigWeight(cache: CacheConfig?, onError: JniErrorHandler<Int>): Int`
 - `celsius_double` — `fun celsiusDouble(c: Int, onError: JniErrorHandler<Int>): Int`
 - `duration_boundary_echo` — `fun durationBoundaryEcho(value: DurationBoundary, onError: JniErrorHandler<DurationBoundary>): DurationBoundary`
@@ -91,8 +97,9 @@ Base package: `io.prebindgen.covertest`
 - `reading_series` — `fun readingSeries(n: Int, onError: JniErrorHandler<List<Reading>>): List<Reading>`
   - shaped by: return `Reading` decomposed → [tag, exact_v0, range_low, range_high, tagged_v0, tagged_v1, companion_v0] (Callback delivery)
 - `stamp_new` — `fun stampNew(secs: Long, nanos: Long, onError: JniErrorHandler<Stamp>): Stamp`
+  - shaped by: return `Stamp` decomposed → [secs, nanos] (Callback delivery)
 - `stamp_series` — `fun stampSeries(count: Long, onError: JniErrorHandler<List<Stamp>>): List<Stamp>`
-  - shaped by: return `Stamp` decomposed → [] (Callback delivery)
+  - shaped by: return `Stamp` decomposed → [secs, nanos] (Callback delivery)
 - `tagged_new` — `fun taggedNew(which: Int, onError: JniErrorHandler<Tagged>): Tagged`
 - `tagged_rank` — `fun taggedRank(t: Tagged, onError: JniErrorHandler<Int>): Int`
 - `unsigned_data_maybe` — `fun unsignedDataMaybe(value: Unsigned, onError: JniErrorHandler<ULong?>): ULong?`
@@ -128,7 +135,7 @@ Base package: `io.prebindgen.covertest`
 - `storage_shards_opt` — `fun storageShardsOpt(count: Long, each: Long, onError: JniErrorHandler<List<Storage>?>): List<Storage>?`
   - shaped by: return `Storage` decomposed → [] (Callback delivery)
 - `storage_total_len` — `fun storageTotalLen(a: Storage, b: Storage, c: Storage, onError: JniErrorHandler<Long>): Long`
-- `storage_try_from_stamp` — `fun storageTryFromStamp(s: Stamp, onBindingError: JniErrorHandler<Storage>, onError: StorageErrorHandler<Storage>): Storage`
+- `storage_try_from_stamp` — `fun storageTryFromStamp(s: Stamp, tag: ByteArray, onBindingError: JniErrorHandler<Storage>, onError: StorageErrorHandler<Storage>): Storage`
   - shaped by: domain error `StorageError` decomposed → onError [message, handle] (binding failures → onBindingError)
 - `storage_try_with_label` — `fun storageTryWithLabel(label: String, onBindingError: JniErrorHandler<Storage>, onError: StorageErrorHandler<Storage>): Storage`
   - shaped by: domain error `StorageError` decomposed → onError [message, handle] (binding failures → onBindingError)
@@ -142,7 +149,7 @@ Base package: `io.prebindgen.covertest`
 
 - `payload_label_len` — `fun labelLen(onError: JniErrorHandler<Long?>): Long?`
 
-## class `io.prebindgen.covertest.model.Stamp` (value_class, Rust `Stamp`)
+## class `io.prebindgen.covertest.model.Stamp` (data_class, Rust `Stamp`)
 
 - `stamp_nanos` — `fun nanos(onError: JniErrorHandler<Long>): Long`
 - `stamp_secs` — `fun secs(onError: JniErrorHandler<Long>): Long`
@@ -170,6 +177,8 @@ Base package: `io.prebindgen.covertest`
 
 - `Annotated`: data_class → `io.prebindgen.covertest.model.Annotated` (wire `jni :: objects :: JObject`)
 - `Archive`: ptr_class → `io.prebindgen.covertest.analytics.SummaryVault` (wire `jni :: sys :: jlong`)
+- `Arrays`: data_class → `io.prebindgen.covertest.model.Arrays` (wire `jni :: objects :: JObject`)
+- `BlobValue`: data_class → `io.prebindgen.covertest.model.BlobValue` (wire `jni :: objects :: JObject`, input `JObject` opt-in)
 - `CacheConfig`: data_class → `io.prebindgen.covertest.model.CacheConfig` (wire `jni :: objects :: JObject`)
 - `DurationBoundary`: data_class → `io.prebindgen.covertest.model.DurationBoundary` (wire `jni :: objects :: JObject`, input `JObject` opt-in)
 - `EscapeProbe`: ptr_class → `io.prebindgen.covertest.esc_pkg.Esc_Probe` (wire `jni :: sys :: jlong`)
@@ -193,7 +202,7 @@ Base package: `io.prebindgen.covertest`
 - `Priority`: enum_class → `io.prebindgen.covertest.model.Priority` (wire `jni :: sys :: jint`)
 - `Reading`: sealed_class → `io.prebindgen.covertest.model.Reading` (wire `?`)
 - `RepliesConfig`: data_class → `io.prebindgen.covertest.model.RepliesConfig` (wire `jni :: objects :: JObject`)
-- `Stamp`: value_class → `io.prebindgen.covertest.model.Stamp` (wire `jni :: objects :: JByteArray`)
+- `Stamp`: data_class → `io.prebindgen.covertest.model.Stamp` (wire `jni :: objects :: JObject`)
 - `Storage`: ptr_class → `io.prebindgen.covertest.Storage` (wire `jni :: sys :: jlong`)
 - `StorageError`: ptr_class → `io.prebindgen.covertest.errors.StorageError` (wire `jni :: sys :: jlong`)
 - `StorageHandler`: ptr_class → `io.prebindgen.covertest.StorageHandler` (wire `jni :: sys :: jlong`)

examples/covertest-kotlin/kotlin/generated/io/prebindgen/covertest.kt

@@ -2,6 +2,7 @@
 package io.prebindgen.covertest
 
 import io.prebindgen.covertest.model.Annotated
+import io.prebindgen.covertest.model.BlobValue
 import io.prebindgen.covertest.model.DurationBoundary
 import io.prebindgen.covertest.model.Hold
 import io.prebindgen.covertest.model.HoldPolicy
@@ -700,6 +701,28 @@ internal object CovNative {
         errorSink: Any,
     )
 
+    external fun arraysEcho(
+        aBytes: ByteArray,
+        aShorts: ShortArray,
+        aInts: IntArray,
+        aLongs: LongArray,
+        aDoubles: DoubleArray,
+        aFlags: BooleanArray,
+        aRaw: LongArray,
+        build: Any,
+        errorSink: Any,
+    ): Any?
+
+    external fun blobValueEcho(value: BlobValue, build: Any, errorSink: Any): Any?
+
+    external fun blobValueNew(
+        secs: Long,
+        id: ByteArray,
+        chunks: List<ByteArray>,
+        build: Any,
+        errorSink: Any,
+    ): Any?
+
     external fun cacheConfigWeight(
         cachePresent: Boolean,
         cacheRepliesPriority: Int,
@@ -809,11 +832,11 @@ internal object CovNative {
 
     external fun readingSeries(n: Int, acc: Any?, fold: Any, errorSink: Any): Any?
 
-    external fun stampNanos(s: ByteArray, errorSink: Any): Long
+    external fun stampNanos(sSecs: Long, sNanos: Long, errorSink: Any): Long
 
-    external fun stampNew(secs: Long, nanos: Long, errorSink: Any): ByteArray
+    external fun stampNew(secs: Long, nanos: Long, build: Any, errorSink: Any): Any?
 
-    external fun stampSecs(s: ByteArray, errorSink: Any): Long
+    external fun stampSecs(sSecs: Long, sNanos: Long, errorSink: Any): Long
 
     external fun stampSeries(count: Long, acc: Any?, fold: Any, errorSink: Any): Any?
 
@@ -914,7 +937,13 @@ internal object CovNative {
 
     external fun storageTotalLen(a: Long, b: Long, c: Long, errorSink: Any): Long
 
-    external fun storageTryFromStamp(s: ByteArray, errorSink: Any, domainSink: Any): Long
+    external fun storageTryFromStamp(
+        sSecs: Long,
+        sNanos: Long,
+        tag: ByteArray,
+        errorSink: Any,
+        domainSink: Any,
+    ): Long
 
     external fun storageTryWithLabel(label: String, errorSink: Any, domainSink: Any): Long