fix: ElapsedTime stays on string wire format (codex P2)

Codex flagged that the structured `{value, unit}` map encoding I switched
to in the previous round was a wire-format change for `@Endpoint` methods
returning `ElapsedTime` directly — the pre-PR toString-quoted body
(`"2.50ms"`) became a JSON object.

Revert to a JSON-string wire shape but use `${et.value}${unit}` rather
than `et.toString` so the value is full-precision (`et.toString` is
%.2f-formatted and rounds 2.555 → 2.56). To keep round-trips lossless for
values that `Double.toString` emits in exponent form (e.g. `1.0E-9`),
extend the `ElapsedTime.parse` regex to accept the exponent suffix.

Drops the structured-map branch + the integer-literal handling that was
specific to it. The simple stringBasedWeaver shape covers the new format.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: xerial

uni/src/main/scala/wvlet/uni/util/ElapsedTime.scala

@@ -56,7 +56,11 @@ object ElapsedTime:
 
   def units = List(NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS)
 
-  private val strReprPattern = Pattern.compile("^\\s*(\\d+(?:\\.\\d+)?)\\s*([a-zA-Z]+)\\s*$")
+  // Number pattern allows decimal, optional fractional part, and optional exponent so the
+  // Weaver round-trip via Double.toString (which can emit "1.0E-9") parses back losslessly.
+  private val strReprPattern = Pattern.compile(
+    "^\\s*(\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)\\s*([a-zA-Z]+)\\s*$"
+  )
 
   def nanosSince(start: Long): ElapsedTime    = succinctNanos(System.nanoTime - start)
   def succinctNanos(nanos: Long): ElapsedTime = succinctDuration(nanos.toDouble, NANOSECONDS)

uni/src/main/scala/wvlet/uni/weaver/codec/PrimitiveWeaver.scala

@@ -804,72 +804,16 @@ object PrimitiveWeaver:
 
   given ulidWeaver: Weaver[ULID] = stringBasedWeaver("ULID", _.toString, ULID(_))
 
-  // ElapsedTime.toString is %.2f-formatted (lossy on the value), and a `${value}${unit}` string
-  // form would only round-trip cleanly when Double.toString avoids exponential notation. Encode
-  // as a structured `{value, unit}` map instead so the original (Double, TimeUnit) pair is
-  // preserved exactly for any value the user could construct.
-  given elapsedTimeWeaver: Weaver[ElapsedTime] =
-    new Weaver[ElapsedTime]:
-      override def pack(p: Packer, v: ElapsedTime, config: WeaverConfig): Unit =
-        p.packMapHeader(2)
-        p.packString("value")
-        p.packDouble(v.value)
-        p.packString("unit")
-        p.packString(ElapsedTime.timeUnitToString(v.unit))
-
-      override def unpack(u: Unpacker, context: WeaverContext): Unit =
-        u.getNextValueType match
-          case ValueType.STRING =>
-            // Backward-compatibility for legacy "<value><unit>" string form (e.g. "2.50ms").
-            safeConvertFromString(
-              context,
-              u,
-              ElapsedTime.parse(_),
-              context.setObject,
-              "ElapsedTime"
-            )
-          case ValueType.MAP =>
-            try
-              val mapSize                             = u.unpackMapHeader
-              var value: Double                       = 0.0
-              var hasValue                            = false
-              var unit: java.util.concurrent.TimeUnit = null
-              var i                                   = 0
-              while i < mapSize do
-                u.unpackString match
-                  case "value" =>
-                    // Accept integer literals like `{"value":5,...}` from JSON producers that
-                    // omit the `.0` for whole-number durations.
-                    value =
-                      u.getNextValueType match
-                        case ValueType.INTEGER =>
-                          u.unpackLong.toDouble
-                        case _ =>
-                          u.unpackDouble
-                    hasValue = true
-                  case "unit" =>
-                    unit = ElapsedTime.valueOfTimeUnit(u.unpackString)
-                  case _ =>
-                    u.skipValue
-                i += 1
-              if !hasValue || unit == null then
-                context.setError(
-                  IllegalArgumentException("ElapsedTime requires both 'value' and 'unit' fields")
-                )
-              else
-                context.setObject(ElapsedTime(value, unit))
-            catch
-              case e: Exception =>
-                context.setError(e)
-          case ValueType.NIL =>
-            safeUnpackNil(context, u)
-          case other =>
-            u.skipValue
-            context.setError(
-              IllegalArgumentException(
-                s"Cannot convert ${other} to ElapsedTime, expected STRING or MAP"
-              )
-            )
+  // Encode as `<value><unit>` (e.g. "2.555s", "1.0E-9ns") rather than `et.toString`, which is
+  // %.2f-rounded and would lose precision on round-trip. ElapsedTime.parse accepts the value
+  // in plain decimal *and* exponent form so any Double.toString output round-trips exactly,
+  // and the wire shape stays a JSON string — matching the pre-PR Router fallback for this
+  // type and avoiding a content-shape change for clients already on the wire.
+  given elapsedTimeWeaver: Weaver[ElapsedTime] = stringBasedWeaver(
+    "ElapsedTime",
+    et => s"${et.value}${ElapsedTime.timeUnitToString(et.unit)}",
+    ElapsedTime.parse(_)
+  )
 
   // Tuple support via recursive given resolution
   trait TupleElementWeaver[T <: Tuple]:

uni/src/test/scala/wvlet/uni/weaver/codec/AdditionalTypeWeaverTest.scala

@@ -379,32 +379,19 @@ class AdditionalTypeWeaverTest extends UniTest:
     tinyBack.unit shouldBe tiny.unit
   }
 
-  test("ElapsedTime accepts legacy string form for backward compatibility") {
+  test("ElapsedTime accepts legacy %.2f-formatted string form") {
     val legacy = "\"2.50ms\""
     val v      = Weaver.fromJson[ElapsedTime](legacy)
     v.value shouldBe 2.5
     v.unit shouldBe TimeUnit.MILLISECONDS
   }
 
-  test("ElapsedTime rejects map missing value or unit") {
-    val noValue = """{"unit":"ms"}"""
-    val e1      = intercept[IllegalArgumentException] {
-      Weaver.fromJson[ElapsedTime](noValue)
-    }
-    e1.getMessage shouldContain "value"
-
-    val noUnit = """{"value":5.0}"""
-    val e2     = intercept[IllegalArgumentException] {
-      Weaver.fromJson[ElapsedTime](noUnit)
-    }
-    e2.getMessage shouldContain "unit"
-  }
-
-  test("ElapsedTime accepts integer value literal") {
-    // JSON producers commonly emit whole numbers without a fractional part. Accept both.
-    val v = Weaver.fromJson[ElapsedTime]("""{"value":5,"unit":"ms"}""")
-    v.value shouldBe 5.0
-    v.unit shouldBe TimeUnit.MILLISECONDS
+  test("ElapsedTime parse accepts exponent form so Double.toString round-trips") {
+    // 1.0E-9 is what `(1.0e-9).toString` produces — the encoder uses Double.toString so the
+    // parse regex must accept this form to avoid losing very small values.
+    val v = ElapsedTime.parse("1.0E-9ns")
+    v.value shouldBe 1.0e-9
+    v.unit shouldBe TimeUnit.NANOSECONDS
   }
 
   // ====== Composite: case class with new types ======