From d100b158150b4b7182573832de6d7fdeb674c317 Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Thu, 2 Jan 2025 08:47:53 -0500
Subject: [PATCH 1/9] temporal: use uppercase unit designator labels by default

This somewhat revives #22, but makes it possible to restore the previous
behavior by enabling `jiff::fmt::temporal::SpanPrinter::lowercase`.

The main motivation here is also detailed in #22, and it came up again
in #188. I was previously reluctant to do this because I find
`P1Y2M3DT4H5M6S` hideously difficult to read and `P1y2m3dT4h5m6s`
somewhat less difficult to read. But now that `jiff::fmt::friendly` is a
thing and users have easy access to a more readable duration display
format, I feel less bad about this. It's still a shame that it's the
default via `span.to_string()`, but I tried to sprinkle a few
`format!("{span:#}")` in places to nudge users toward the friendly
format.

It's a shame more systems don't accept lowercase unit designator labels,
but since Jiff uses the ISO 8601 by default specifically for its
interoperability, it makes sense to be as interoperable as we can by
default.

Fixes #188
---
 CHANGELOG.md                           |   3 +
 COMPARE.md                             |   2 +-
 src/civil/date.rs                      |   4 +-
 src/civil/datetime.rs                  |   4 +-
 src/civil/time.rs                      |   4 +-
 src/fmt/friendly/mod.rs                |  13 +-
 src/fmt/friendly/parser.rs             | 214 ++++++++++++-------------
 src/fmt/temporal/mod.rs                |  45 ++++--
 src/fmt/temporal/printer.rs            | 167 ++++++++++---------
 src/lib.rs                             |   4 +-
 src/signed_duration.rs                 |  28 ++--
 src/span.rs                            |  76 ++++-----
 src/timestamp.rs                       |   4 +-
 src/zoned.rs                           |   4 +-
 tests/tc39_262/civil/datetime/until.rs |  10 +-
 tests/tc39_262/civil/time/until.rs     |  34 ++--
 tests/tc39_262/span/round.rs           |   6 +-
 17 files changed, 337 insertions(+), 285 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 69c503a4..c8b8fabe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,9 @@ Bug fixes:
 
 * [#155](https://github.com/BurntSushi/jiff/issues/155):
 Relax `strftime` format strings from ASCII-only to all of UTF-8.
+* [#188](https://github.com/BurntSushi/jiff/issues/188):
+`Span` and `SignedDuration` now use uppercase unit designator labels in their
+default ISO 8601 `Display` implementation.
 
 
 0.1.18 (2024-12-31)
diff --git a/COMPARE.md b/COMPARE.md
index 6ebf29c3..40543858 100644
--- a/COMPARE.md
+++ b/COMPARE.md
@@ -328,7 +328,7 @@ use jiff::{Span, ToSpan};
 fn main() -> anyhow::Result<()> {
     let span = 5.years().months(2).days(1).hours(20);
     let json = serde_json::to_string_pretty(&span)?;
-    assert_eq!(json, "\"P5y2m1dT20h\"");
+    assert_eq!(json, "\"P5Y2M1DT20H\"");
 
     let got: Span = serde_json::from_str(&json)?;
     assert_eq!(got, span);
diff --git a/src/civil/date.rs b/src/civil/date.rs
index 5374edf2..165fb8e3 100644
--- a/src/civil/date.rs
+++ b/src/civil/date.rs
@@ -1635,11 +1635,11 @@ impl Date {
     ///
     /// // The default limits durations to using "days" as the biggest unit.
     /// let span = d1.until(d2)?;
-    /// assert_eq!(span.to_string(), "P8456d");
+    /// assert_eq!(span.to_string(), "P8456D");
     ///
     /// // But we can ask for units all the way up to years.
     /// let span = d1.until((Unit::Year, d2))?;
-    /// assert_eq!(span.to_string(), "P23y1m24d");
+    /// assert_eq!(span.to_string(), "P23Y1M24D");
     ///
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
diff --git a/src/civil/datetime.rs b/src/civil/datetime.rs
index 046e0811..8e736a19 100644
--- a/src/civil/datetime.rs
+++ b/src/civil/datetime.rs
@@ -1775,11 +1775,11 @@ impl DateTime {
     ///
     /// // The default limits durations to using "days" as the biggest unit.
     /// let span = dt1.until(dt2)?;
-    /// assert_eq!(span.to_string(), "P8456dT12h5m29.9999965s");
+    /// assert_eq!(span.to_string(), "P8456DT12H5M29.9999965S");
     ///
     /// // But we can ask for units all the way up to years.
     /// let span = dt1.until((Unit::Year, dt2))?;
-    /// assert_eq!(span.to_string(), "P23y1m24dT12h5m29.9999965s");
+    /// assert_eq!(span.to_string(), "P23Y1M24DT12H5M29.9999965S");
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     ///
diff --git a/src/civil/time.rs b/src/civil/time.rs
index f085cdec..15ee4c51 100644
--- a/src/civil/time.rs
+++ b/src/civil/time.rs
@@ -1198,12 +1198,12 @@ impl Time {
     ///
     /// // The default limits spans to using "hours" as the biggest unit.
     /// let span = t1.until(t2)?;
-    /// assert_eq!(span.to_string(), "PT12h5m29.9999965s");
+    /// assert_eq!(span.to_string(), "PT12H5M29.9999965S");
     ///
     /// // But we can ask for smaller units, like capping the biggest unit
     /// // to minutes instead of hours.
     /// let span = t1.until((Unit::Minute, t2))?;
-    /// assert_eq!(span.to_string(), "PT725m29.9999965s");
+    /// assert_eq!(span.to_string(), "PT725M29.9999965S");
     ///
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
diff --git a/src/fmt/friendly/mod.rs b/src/fmt/friendly/mod.rs
index cb36b741..b47a909b 100644
--- a/src/fmt/friendly/mod.rs
+++ b/src/fmt/friendly/mod.rs
@@ -77,11 +77,11 @@ format when using the `std::fmt::Display` trait implementation:
 use jiff::{SignedDuration, ToSpan};
 
 let span = 2.months().days(35).hours(2).minutes(30);
-assert_eq!(format!("{span}"), "P2m35dT2h30m");      // ISO 8601
+assert_eq!(format!("{span}"), "P2M35DT2H30M");      // ISO 8601
 assert_eq!(format!("{span:#}"), "2mo 35d 2h 30m");  // "friendly"
 
 let sdur = SignedDuration::new(2 * 60 * 60 + 30 * 60, 123_456_789);
-assert_eq!(format!("{sdur}"), "PT2h30m0.123456789s");         // ISO 8601
+assert_eq!(format!("{sdur}"), "PT2H30M0.123456789S");         // ISO 8601
 assert_eq!(format!("{sdur:#}"), "2h 30m 123ms 456µs 789ns");  // "friendly"
 ```
 
@@ -467,10 +467,11 @@ P1Y2M3DT4H59M1.1S
 P1y2m3dT4h59m1.1S
 ```
 
-When all of the unit designators are capital letters in particular, everything
-runs together and it's hard for the eye to distinguish where digits stop and
-letters begin. Using lowercase letters for unit designators helps somewhat,
-but this is an extension to ISO 8601 that isn't broadly supported.
+When all of the unit designators are capital letters in particular (which
+is the default), everything runs together and it's hard for the eye to
+distinguish where digits stop and letters begin. Using lowercase letters for
+unit designators helps somewhat, but this is an extension to ISO 8601 that
+isn't broadly supported.
 
 The "friendly" format resolves both of these problems by permitting sub-second
 components and allowing the use of whitespace and longer unit designator labels
diff --git a/src/fmt/friendly/parser.rs b/src/fmt/friendly/parser.rs
index 60b6373a..e49c9056 100644
--- a/src/fmt/friendly/parser.rs
+++ b/src/fmt/friendly/parser.rs
@@ -975,78 +975,78 @@ mod tests {
     fn parse_span_basic() {
         let p = |s: &str| SpanParser::new().parse_span(s).unwrap();
 
-        insta::assert_snapshot!(p("5 years"), @"P5y");
-        insta::assert_snapshot!(p("5 years 4 months"), @"P5y4m");
-        insta::assert_snapshot!(p("5 years 4 months 3 hours"), @"P5y4mT3h");
-        insta::assert_snapshot!(p("5 years, 4 months, 3 hours"), @"P5y4mT3h");
+        insta::assert_snapshot!(p("5 years"), @"P5Y");
+        insta::assert_snapshot!(p("5 years 4 months"), @"P5Y4M");
+        insta::assert_snapshot!(p("5 years 4 months 3 hours"), @"P5Y4MT3H");
+        insta::assert_snapshot!(p("5 years, 4 months, 3 hours"), @"P5Y4MT3H");
 
-        insta::assert_snapshot!(p("01:02:03"), @"PT1h2m3s");
-        insta::assert_snapshot!(p("5 days 01:02:03"), @"P5dT1h2m3s");
+        insta::assert_snapshot!(p("01:02:03"), @"PT1H2M3S");
+        insta::assert_snapshot!(p("5 days 01:02:03"), @"P5DT1H2M3S");
         // This is Python's `str(timedelta)` format!
-        insta::assert_snapshot!(p("5 days, 01:02:03"), @"P5dT1h2m3s");
-        insta::assert_snapshot!(p("3yrs 5 days 01:02:03"), @"P3y5dT1h2m3s");
-        insta::assert_snapshot!(p("3yrs 5 days, 01:02:03"), @"P3y5dT1h2m3s");
+        insta::assert_snapshot!(p("5 days, 01:02:03"), @"P5DT1H2M3S");
+        insta::assert_snapshot!(p("3yrs 5 days 01:02:03"), @"P3Y5DT1H2M3S");
+        insta::assert_snapshot!(p("3yrs 5 days, 01:02:03"), @"P3Y5DT1H2M3S");
         insta::assert_snapshot!(
             p("3yrs 5 days, 01:02:03.123456789"),
-            @"P3y5dT1h2m3.123456789s",
+            @"P3Y5DT1H2M3.123456789S",
         );
-        insta::assert_snapshot!(p("999:999:999"), @"PT999h999m999s");
+        insta::assert_snapshot!(p("999:999:999"), @"PT999H999M999S");
     }
 
     #[test]
     fn parse_span_fractional() {
         let p = |s: &str| SpanParser::new().parse_span(s).unwrap();
 
-        insta::assert_snapshot!(p("1.5hrs"), @"PT1h30m");
-        insta::assert_snapshot!(p("1.5mins"), @"PT1m30s");
-        insta::assert_snapshot!(p("1.5secs"), @"PT1.5s");
-        insta::assert_snapshot!(p("1.5msecs"), @"PT0.0015s");
-        insta::assert_snapshot!(p("1.5µsecs"), @"PT0.0000015s");
+        insta::assert_snapshot!(p("1.5hrs"), @"PT1H30M");
+        insta::assert_snapshot!(p("1.5mins"), @"PT1M30S");
+        insta::assert_snapshot!(p("1.5secs"), @"PT1.5S");
+        insta::assert_snapshot!(p("1.5msecs"), @"PT0.0015S");
+        insta::assert_snapshot!(p("1.5µsecs"), @"PT0.0000015S");
 
-        insta::assert_snapshot!(p("1d 1.5hrs"), @"P1dT1h30m");
-        insta::assert_snapshot!(p("1h 1.5mins"), @"PT1h1m30s");
-        insta::assert_snapshot!(p("1m 1.5secs"), @"PT1m1.5s");
-        insta::assert_snapshot!(p("1s 1.5msecs"), @"PT1.0015s");
-        insta::assert_snapshot!(p("1ms 1.5µsecs"), @"PT0.0010015s");
+        insta::assert_snapshot!(p("1d 1.5hrs"), @"P1DT1H30M");
+        insta::assert_snapshot!(p("1h 1.5mins"), @"PT1H1M30S");
+        insta::assert_snapshot!(p("1m 1.5secs"), @"PT1M1.5S");
+        insta::assert_snapshot!(p("1s 1.5msecs"), @"PT1.0015S");
+        insta::assert_snapshot!(p("1ms 1.5µsecs"), @"PT0.0010015S");
 
-        insta::assert_snapshot!(p("1s2000ms"), @"PT3s");
+        insta::assert_snapshot!(p("1s2000ms"), @"PT3S");
     }
 
     #[test]
     fn parse_span_boundaries() {
         let p = |s: &str| SpanParser::new().parse_span(s).unwrap();
 
-        insta::assert_snapshot!(p("19998 years"), @"P19998y");
-        insta::assert_snapshot!(p("19998 years ago"), @"-P19998y");
-        insta::assert_snapshot!(p("239976 months"), @"P239976m");
-        insta::assert_snapshot!(p("239976 months ago"), @"-P239976m");
-        insta::assert_snapshot!(p("1043497 weeks"), @"P1043497w");
-        insta::assert_snapshot!(p("1043497 weeks ago"), @"-P1043497w");
-        insta::assert_snapshot!(p("7304484 days"), @"P7304484d");
-        insta::assert_snapshot!(p("7304484 days ago"), @"-P7304484d");
-        insta::assert_snapshot!(p("175307616 hours"), @"PT175307616h");
-        insta::assert_snapshot!(p("175307616 hours ago"), @"-PT175307616h");
-        insta::assert_snapshot!(p("10518456960 minutes"), @"PT10518456960m");
-        insta::assert_snapshot!(p("10518456960 minutes ago"), @"-PT10518456960m");
-        insta::assert_snapshot!(p("631107417600 seconds"), @"PT631107417600s");
-        insta::assert_snapshot!(p("631107417600 seconds ago"), @"-PT631107417600s");
-        insta::assert_snapshot!(p("631107417600000 milliseconds"), @"PT631107417600s");
-        insta::assert_snapshot!(p("631107417600000 milliseconds ago"), @"-PT631107417600s");
-        insta::assert_snapshot!(p("631107417600000000 microseconds"), @"PT631107417600s");
-        insta::assert_snapshot!(p("631107417600000000 microseconds ago"), @"-PT631107417600s");
-        insta::assert_snapshot!(p("9223372036854775807 nanoseconds"), @"PT9223372036.854775807s");
-        insta::assert_snapshot!(p("9223372036854775807 nanoseconds ago"), @"-PT9223372036.854775807s");
-
-        insta::assert_snapshot!(p("175307617 hours"), @"PT175307616h60m");
-        insta::assert_snapshot!(p("175307617 hours ago"), @"-PT175307616h60m");
-        insta::assert_snapshot!(p("10518456961 minutes"), @"PT10518456960m60s");
-        insta::assert_snapshot!(p("10518456961 minutes ago"), @"-PT10518456960m60s");
-        insta::assert_snapshot!(p("631107417601 seconds"), @"PT631107417601s");
-        insta::assert_snapshot!(p("631107417601 seconds ago"), @"-PT631107417601s");
-        insta::assert_snapshot!(p("631107417600001 milliseconds"), @"PT631107417600.001s");
-        insta::assert_snapshot!(p("631107417600001 milliseconds ago"), @"-PT631107417600.001s");
-        insta::assert_snapshot!(p("631107417600000001 microseconds"), @"PT631107417600.000001s");
-        insta::assert_snapshot!(p("631107417600000001 microseconds ago"), @"-PT631107417600.000001s");
+        insta::assert_snapshot!(p("19998 years"), @"P19998Y");
+        insta::assert_snapshot!(p("19998 years ago"), @"-P19998Y");
+        insta::assert_snapshot!(p("239976 months"), @"P239976M");
+        insta::assert_snapshot!(p("239976 months ago"), @"-P239976M");
+        insta::assert_snapshot!(p("1043497 weeks"), @"P1043497W");
+        insta::assert_snapshot!(p("1043497 weeks ago"), @"-P1043497W");
+        insta::assert_snapshot!(p("7304484 days"), @"P7304484D");
+        insta::assert_snapshot!(p("7304484 days ago"), @"-P7304484D");
+        insta::assert_snapshot!(p("175307616 hours"), @"PT175307616H");
+        insta::assert_snapshot!(p("175307616 hours ago"), @"-PT175307616H");
+        insta::assert_snapshot!(p("10518456960 minutes"), @"PT10518456960M");
+        insta::assert_snapshot!(p("10518456960 minutes ago"), @"-PT10518456960M");
+        insta::assert_snapshot!(p("631107417600 seconds"), @"PT631107417600S");
+        insta::assert_snapshot!(p("631107417600 seconds ago"), @"-PT631107417600S");
+        insta::assert_snapshot!(p("631107417600000 milliseconds"), @"PT631107417600S");
+        insta::assert_snapshot!(p("631107417600000 milliseconds ago"), @"-PT631107417600S");
+        insta::assert_snapshot!(p("631107417600000000 microseconds"), @"PT631107417600S");
+        insta::assert_snapshot!(p("631107417600000000 microseconds ago"), @"-PT631107417600S");
+        insta::assert_snapshot!(p("9223372036854775807 nanoseconds"), @"PT9223372036.854775807S");
+        insta::assert_snapshot!(p("9223372036854775807 nanoseconds ago"), @"-PT9223372036.854775807S");
+
+        insta::assert_snapshot!(p("175307617 hours"), @"PT175307616H60M");
+        insta::assert_snapshot!(p("175307617 hours ago"), @"-PT175307616H60M");
+        insta::assert_snapshot!(p("10518456961 minutes"), @"PT10518456960M60S");
+        insta::assert_snapshot!(p("10518456961 minutes ago"), @"-PT10518456960M60S");
+        insta::assert_snapshot!(p("631107417601 seconds"), @"PT631107417601S");
+        insta::assert_snapshot!(p("631107417601 seconds ago"), @"-PT631107417601S");
+        insta::assert_snapshot!(p("631107417600001 milliseconds"), @"PT631107417600.001S");
+        insta::assert_snapshot!(p("631107417600001 milliseconds ago"), @"-PT631107417600.001S");
+        insta::assert_snapshot!(p("631107417600000001 microseconds"), @"PT631107417600.000001S");
+        insta::assert_snapshot!(p("631107417600000001 microseconds ago"), @"-PT631107417600.000001S");
         // We don't include nanoseconds here, because that will fail to
         // parse due to overflowing i64.
     }
@@ -1073,7 +1073,7 @@ mod tests {
         );
         insta::assert_snapshot!(
             p("1 year 1 mont"),
-            @r###"failed to parse "1 year 1 mont" in the "friendly" format: parsed value 'P1y1m', but unparsed input "nt" remains (expected no unparsed input)"###,
+            @r###"failed to parse "1 year 1 mont" in the "friendly" format: parsed value 'P1Y1M', but unparsed input "nt" remains (expected no unparsed input)"###,
         );
         insta::assert_snapshot!(
             p("2 months,"),
@@ -1085,7 +1085,7 @@ mod tests {
         );
         insta::assert_snapshot!(
             p("2 months ,"),
-            @r###"failed to parse "2 months ," in the "friendly" format: parsed value 'P2m', but unparsed input "," remains (expected no unparsed input)"###,
+            @r###"failed to parse "2 months ," in the "friendly" format: parsed value 'P2M', but unparsed input "," remains (expected no unparsed input)"###,
         );
     }
 
@@ -1095,11 +1095,11 @@ mod tests {
 
         insta::assert_snapshot!(
             p("1yago"),
-            @r###"failed to parse "1yago" in the "friendly" format: parsed value 'P1y', but unparsed input "ago" remains (expected no unparsed input)"###,
+            @r###"failed to parse "1yago" in the "friendly" format: parsed value 'P1Y', but unparsed input "ago" remains (expected no unparsed input)"###,
         );
         insta::assert_snapshot!(
             p("1 year 1 monthago"),
-            @r###"failed to parse "1 year 1 monthago" in the "friendly" format: parsed value 'P1y1m', but unparsed input "ago" remains (expected no unparsed input)"###,
+            @r###"failed to parse "1 year 1 monthago" in the "friendly" format: parsed value 'P1Y1M', but unparsed input "ago" remains (expected no unparsed input)"###,
         );
         insta::assert_snapshot!(
             p("+1 year 1 month ago"),
@@ -1126,7 +1126,7 @@ mod tests {
         // one fewer is okay
         insta::assert_snapshot!(
             p("640330789636854775 micros"),
-            @"PT640330789636.854775s"
+            @"PT640330789636.854775S"
         );
 
         insta::assert_snapshot!(
@@ -1139,7 +1139,7 @@ mod tests {
         // one fewer is okay
         insta::assert_snapshot!(
             p("640330789636854775.807 micros"),
-            @"PT640330789636.854775807s"
+            @"PT640330789636.854775807S"
         );
     }
 
@@ -1233,9 +1233,9 @@ mod tests {
     fn parse_duration_basic() {
         let p = |s: &str| SpanParser::new().parse_duration(s).unwrap();
 
-        insta::assert_snapshot!(p("1 hour, 2 minutes, 3 seconds"), @"PT1h2m3s");
-        insta::assert_snapshot!(p("01:02:03"), @"PT1h2m3s");
-        insta::assert_snapshot!(p("999:999:999"), @"PT1015h55m39s");
+        insta::assert_snapshot!(p("1 hour, 2 minutes, 3 seconds"), @"PT1H2M3S");
+        insta::assert_snapshot!(p("01:02:03"), @"PT1H2M3S");
+        insta::assert_snapshot!(p("999:999:999"), @"PT1015H55M39S");
     }
 
     #[test]
@@ -1245,7 +1245,7 @@ mod tests {
 
         insta::assert_snapshot!(
             p("9223372036854775807s"),
-            @"PT2562047788015215h30m7s",
+            @"PT2562047788015215H30M7S",
         );
         insta::assert_snapshot!(
             perr("9223372036854775808s"),
@@ -1269,18 +1269,18 @@ mod tests {
     fn parse_duration_fractional() {
         let p = |s: &str| SpanParser::new().parse_duration(s).unwrap();
 
-        insta::assert_snapshot!(p("1.5hrs"), @"PT1h30m");
-        insta::assert_snapshot!(p("1.5mins"), @"PT1m30s");
-        insta::assert_snapshot!(p("1.5secs"), @"PT1.5s");
-        insta::assert_snapshot!(p("1.5msecs"), @"PT0.0015s");
-        insta::assert_snapshot!(p("1.5µsecs"), @"PT0.0000015s");
+        insta::assert_snapshot!(p("1.5hrs"), @"PT1H30M");
+        insta::assert_snapshot!(p("1.5mins"), @"PT1M30S");
+        insta::assert_snapshot!(p("1.5secs"), @"PT1.5S");
+        insta::assert_snapshot!(p("1.5msecs"), @"PT0.0015S");
+        insta::assert_snapshot!(p("1.5µsecs"), @"PT0.0000015S");
 
-        insta::assert_snapshot!(p("1h 1.5mins"), @"PT1h1m30s");
-        insta::assert_snapshot!(p("1m 1.5secs"), @"PT1m1.5s");
-        insta::assert_snapshot!(p("1s 1.5msecs"), @"PT1.0015s");
-        insta::assert_snapshot!(p("1ms 1.5µsecs"), @"PT0.0010015s");
+        insta::assert_snapshot!(p("1h 1.5mins"), @"PT1H1M30S");
+        insta::assert_snapshot!(p("1m 1.5secs"), @"PT1M1.5S");
+        insta::assert_snapshot!(p("1s 1.5msecs"), @"PT1.0015S");
+        insta::assert_snapshot!(p("1ms 1.5µsecs"), @"PT0.0010015S");
 
-        insta::assert_snapshot!(p("1s2000ms"), @"PT3s");
+        insta::assert_snapshot!(p("1s2000ms"), @"PT3S");
     }
 
     #[test]
@@ -1288,51 +1288,51 @@ mod tests {
         let p = |s: &str| SpanParser::new().parse_duration(s).unwrap();
         let pe = |s: &str| SpanParser::new().parse_duration(s).unwrap_err();
 
-        insta::assert_snapshot!(p("175307616 hours"), @"PT175307616h");
-        insta::assert_snapshot!(p("175307616 hours ago"), @"-PT175307616h");
-        insta::assert_snapshot!(p("10518456960 minutes"), @"PT175307616h");
-        insta::assert_snapshot!(p("10518456960 minutes ago"), @"-PT175307616h");
-        insta::assert_snapshot!(p("631107417600 seconds"), @"PT175307616h");
-        insta::assert_snapshot!(p("631107417600 seconds ago"), @"-PT175307616h");
-        insta::assert_snapshot!(p("631107417600000 milliseconds"), @"PT175307616h");
-        insta::assert_snapshot!(p("631107417600000 milliseconds ago"), @"-PT175307616h");
-        insta::assert_snapshot!(p("631107417600000000 microseconds"), @"PT175307616h");
-        insta::assert_snapshot!(p("631107417600000000 microseconds ago"), @"-PT175307616h");
-        insta::assert_snapshot!(p("9223372036854775807 nanoseconds"), @"PT2562047h47m16.854775807s");
-        insta::assert_snapshot!(p("9223372036854775807 nanoseconds ago"), @"-PT2562047h47m16.854775807s");
-
-        insta::assert_snapshot!(p("175307617 hours"), @"PT175307617h");
-        insta::assert_snapshot!(p("175307617 hours ago"), @"-PT175307617h");
-        insta::assert_snapshot!(p("10518456961 minutes"), @"PT175307616h1m");
-        insta::assert_snapshot!(p("10518456961 minutes ago"), @"-PT175307616h1m");
-        insta::assert_snapshot!(p("631107417601 seconds"), @"PT175307616h1s");
-        insta::assert_snapshot!(p("631107417601 seconds ago"), @"-PT175307616h1s");
-        insta::assert_snapshot!(p("631107417600001 milliseconds"), @"PT175307616h0.001s");
-        insta::assert_snapshot!(p("631107417600001 milliseconds ago"), @"-PT175307616h0.001s");
-        insta::assert_snapshot!(p("631107417600000001 microseconds"), @"PT175307616h0.000001s");
-        insta::assert_snapshot!(p("631107417600000001 microseconds ago"), @"-PT175307616h0.000001s");
+        insta::assert_snapshot!(p("175307616 hours"), @"PT175307616H");
+        insta::assert_snapshot!(p("175307616 hours ago"), @"-PT175307616H");
+        insta::assert_snapshot!(p("10518456960 minutes"), @"PT175307616H");
+        insta::assert_snapshot!(p("10518456960 minutes ago"), @"-PT175307616H");
+        insta::assert_snapshot!(p("631107417600 seconds"), @"PT175307616H");
+        insta::assert_snapshot!(p("631107417600 seconds ago"), @"-PT175307616H");
+        insta::assert_snapshot!(p("631107417600000 milliseconds"), @"PT175307616H");
+        insta::assert_snapshot!(p("631107417600000 milliseconds ago"), @"-PT175307616H");
+        insta::assert_snapshot!(p("631107417600000000 microseconds"), @"PT175307616H");
+        insta::assert_snapshot!(p("631107417600000000 microseconds ago"), @"-PT175307616H");
+        insta::assert_snapshot!(p("9223372036854775807 nanoseconds"), @"PT2562047H47M16.854775807S");
+        insta::assert_snapshot!(p("9223372036854775807 nanoseconds ago"), @"-PT2562047H47M16.854775807S");
+
+        insta::assert_snapshot!(p("175307617 hours"), @"PT175307617H");
+        insta::assert_snapshot!(p("175307617 hours ago"), @"-PT175307617H");
+        insta::assert_snapshot!(p("10518456961 minutes"), @"PT175307616H1M");
+        insta::assert_snapshot!(p("10518456961 minutes ago"), @"-PT175307616H1M");
+        insta::assert_snapshot!(p("631107417601 seconds"), @"PT175307616H1S");
+        insta::assert_snapshot!(p("631107417601 seconds ago"), @"-PT175307616H1S");
+        insta::assert_snapshot!(p("631107417600001 milliseconds"), @"PT175307616H0.001S");
+        insta::assert_snapshot!(p("631107417600001 milliseconds ago"), @"-PT175307616H0.001S");
+        insta::assert_snapshot!(p("631107417600000001 microseconds"), @"PT175307616H0.000001S");
+        insta::assert_snapshot!(p("631107417600000001 microseconds ago"), @"-PT175307616H0.000001S");
         // We don't include nanoseconds here, because that will fail to
         // parse due to overflowing i64.
 
         // The above were copied from the corresponding `Span` test, which has
         // tighter limits on components. But a `SignedDuration` supports the
         // full range of `i64` seconds.
-        insta::assert_snapshot!(p("2562047788015215hours"), @"PT2562047788015215h");
-        insta::assert_snapshot!(p("-2562047788015215hours"), @"-PT2562047788015215h");
+        insta::assert_snapshot!(p("2562047788015215hours"), @"PT2562047788015215H");
+        insta::assert_snapshot!(p("-2562047788015215hours"), @"-PT2562047788015215H");
         insta::assert_snapshot!(
             pe("2562047788015216hrs"),
             @r###"failed to parse "2562047788015216hrs" in the "friendly" format: converting 2562047788015216 hours to seconds overflows i64"###,
         );
 
-        insta::assert_snapshot!(p("153722867280912930minutes"), @"PT2562047788015215h30m");
-        insta::assert_snapshot!(p("153722867280912930minutes ago"), @"-PT2562047788015215h30m");
+        insta::assert_snapshot!(p("153722867280912930minutes"), @"PT2562047788015215H30M");
+        insta::assert_snapshot!(p("153722867280912930minutes ago"), @"-PT2562047788015215H30M");
         insta::assert_snapshot!(
             pe("153722867280912931mins"),
             @r###"failed to parse "153722867280912931mins" in the "friendly" format: parameter 'minutes-to-seconds' with value 60 is not in the required range of -9223372036854775808..=9223372036854775807"###,
         );
 
-        insta::assert_snapshot!(p("9223372036854775807seconds"), @"PT2562047788015215h30m7s");
-        insta::assert_snapshot!(p("-9223372036854775807seconds"), @"-PT2562047788015215h30m7s");
+        insta::assert_snapshot!(p("9223372036854775807seconds"), @"PT2562047788015215H30M7S");
+        insta::assert_snapshot!(p("-9223372036854775807seconds"), @"-PT2562047788015215H30M7S");
         insta::assert_snapshot!(
             pe("9223372036854775808s"),
             @r###"failed to parse "9223372036854775808s" in the "friendly" format: number '9223372036854775808' too big to parse into 64-bit integer"###,
@@ -1369,7 +1369,7 @@ mod tests {
         );
         insta::assert_snapshot!(
             p("1 hour 1 minut"),
-            @r###"failed to parse "1 hour 1 minut" in the "friendly" format: parsed value 'PT1h1m', but unparsed input "ut" remains (expected no unparsed input)"###,
+            @r###"failed to parse "1 hour 1 minut" in the "friendly" format: parsed value 'PT1H1M', but unparsed input "ut" remains (expected no unparsed input)"###,
         );
         insta::assert_snapshot!(
             p("2 minutes,"),
@@ -1381,7 +1381,7 @@ mod tests {
         );
         insta::assert_snapshot!(
             p("2 minutes ,"),
-            @r###"failed to parse "2 minutes ," in the "friendly" format: parsed value 'PT2m', but unparsed input "," remains (expected no unparsed input)"###,
+            @r###"failed to parse "2 minutes ," in the "friendly" format: parsed value 'PT2M', but unparsed input "," remains (expected no unparsed input)"###,
         );
     }
 
@@ -1391,11 +1391,11 @@ mod tests {
 
         insta::assert_snapshot!(
             p("1hago"),
-            @r###"failed to parse "1hago" in the "friendly" format: parsed value 'PT1h', but unparsed input "ago" remains (expected no unparsed input)"###,
+            @r###"failed to parse "1hago" in the "friendly" format: parsed value 'PT1H', but unparsed input "ago" remains (expected no unparsed input)"###,
         );
         insta::assert_snapshot!(
             p("1 hour 1 minuteago"),
-            @r###"failed to parse "1 hour 1 minuteago" in the "friendly" format: parsed value 'PT1h1m', but unparsed input "ago" remains (expected no unparsed input)"###,
+            @r###"failed to parse "1 hour 1 minuteago" in the "friendly" format: parsed value 'PT1H1M', but unparsed input "ago" remains (expected no unparsed input)"###,
         );
         insta::assert_snapshot!(
             p("+1 hour 1 minute ago"),
@@ -1421,7 +1421,7 @@ mod tests {
         // one fewer is okay
         insta::assert_snapshot!(
             p("9223372036854775807 micros"),
-            @"PT2562047788h54.775807s"
+            @"PT2562047788H54.775807S"
         );
     }
 
diff --git a/src/fmt/temporal/mod.rs b/src/fmt/temporal/mod.rs
index 95f898a4..a1bfdd42 100644
--- a/src/fmt/temporal/mod.rs
+++ b/src/fmt/temporal/mod.rs
@@ -68,8 +68,11 @@ But there are some details not easily captured by a simple regular expression:
 
 * At least one unit must be specified. To write a zero span, specify `0` for
 any unit. For example, `P0d` and `PT0s` are equivalent.
-* The format is case insensitive. The printer will by default capitalize the
-`P` and `T` designators, but lowercase the unit designators.
+* The format is case insensitive. The printer will by default capitalize all
+designators, but the unit designators can be configured to use lowercase with
+[`SpanPrinter::lowercase`]. For example, `P3y1m10dT5h` instead of
+`P3Y1M10DT5H`. You might prefer lowercase since you may find it easier to read.
+However, it is an extension to ISO 8601 and isn't as broadly supported.
 * Hours, minutes or seconds may be fractional. And the only units that may be
 fractional are the lowest units.
 * A span like `P99999999999y` is invalid because it exceeds the allowable range
@@ -1566,7 +1569,7 @@ impl SpanParser {
 /// let mut buf = vec![];
 /// // Printing to a `Vec<u8>` can never fail.
 /// PRINTER.print_span(&span, &mut buf).unwrap();
-/// assert_eq!(buf, "PT48m".as_bytes());
+/// assert_eq!(buf, "PT48M".as_bytes());
 /// ```
 ///
 /// # Example: using adapters with `std::io::Write` and `std::fmt::Write`
@@ -1605,6 +1608,30 @@ impl SpanPrinter {
         SpanPrinter { p: printer::SpanPrinter::new() }
     }
 
+    /// Use lowercase for unit designator labels.
+    ///
+    /// By default, unit designator labels are written in uppercase.
+    ///
+    /// # Example
+    ///
+    /// This shows the difference between the default (uppercase) and enabling
+    /// lowercase. Lowercase unit designator labels tend to be easier to read
+    /// (in this author's opinion), but they aren't as broadly supported since
+    /// they are an extension to ISO 8601.
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::SpanPrinter, ToSpan};
+    ///
+    /// let span = 5.years().days(10).hours(1);
+    /// let printer = SpanPrinter::new();
+    /// assert_eq!(printer.span_to_string(&span), "P5Y10DT1H");
+    /// assert_eq!(printer.lowercase(true).span_to_string(&span), "P5y10dT1h");
+    /// ```
+    #[inline]
+    pub const fn lowercase(self, yes: bool) -> SpanPrinter {
+        SpanPrinter { p: self.p.lowercase(yes) }
+    }
+
     /// Format a `Span` into a string.
     ///
     /// This is a convenience routine for [`SpanPrinter::print_span`] with
@@ -1618,7 +1645,7 @@ impl SpanPrinter {
     /// const PRINTER: SpanPrinter = SpanPrinter::new();
     ///
     /// let span = 3.years().months(5);
-    /// assert_eq!(PRINTER.span_to_string(&span), "P3y5m");
+    /// assert_eq!(PRINTER.span_to_string(&span), "P3Y5M");
     ///
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
@@ -1646,8 +1673,8 @@ impl SpanPrinter {
     /// const PRINTER: SpanPrinter = SpanPrinter::new();
     ///
     /// let dur = SignedDuration::new(86_525, 123_000_789);
-    /// assert_eq!(PRINTER.duration_to_string(&dur), "PT24h2m5.123000789s");
-    /// assert_eq!(PRINTER.duration_to_string(&-dur), "-PT24h2m5.123000789s");
+    /// assert_eq!(PRINTER.duration_to_string(&dur), "PT24H2M5.123000789S");
+    /// assert_eq!(PRINTER.duration_to_string(&-dur), "-PT24H2M5.123000789S");
     ///
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
@@ -1683,7 +1710,7 @@ impl SpanPrinter {
     /// let mut buf = String::new();
     /// // Printing to a `String` can never fail.
     /// PRINTER.print_span(&span, &mut buf).unwrap();
-    /// assert_eq!(buf, "P3y5m");
+    /// assert_eq!(buf, "P3Y5M");
     ///
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
@@ -1719,12 +1746,12 @@ impl SpanPrinter {
     /// let mut buf = String::new();
     /// // Printing to a `String` can never fail.
     /// PRINTER.print_duration(&dur, &mut buf).unwrap();
-    /// assert_eq!(buf, "PT24h2m5.123000789s");
+    /// assert_eq!(buf, "PT24H2M5.123000789S");
     ///
     /// // Negative durations are supported.
     /// buf.clear();
     /// PRINTER.print_duration(&-dur, &mut buf).unwrap();
-    /// assert_eq!(buf, "-PT24h2m5.123000789s");
+    /// assert_eq!(buf, "-PT24H2M5.123000789S");
     ///
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
diff --git a/src/fmt/temporal/printer.rs b/src/fmt/temporal/printer.rs
index c65ce819..0597c3c9 100644
--- a/src/fmt/temporal/printer.rs
+++ b/src/fmt/temporal/printer.rs
@@ -220,14 +220,21 @@ impl Default for DateTimePrinter {
 /// Note that in Temporal, a "span" is called a "duration."
 #[derive(Debug)]
 pub(super) struct SpanPrinter {
-    /// There are currently no configuration options for this printer.
-    _priv: (),
+    /// Whether to use lowercase unit designators.
+    lowercase: bool,
 }
 
 impl SpanPrinter {
     /// Create a new Temporal span printer with the default configuration.
     pub(super) const fn new() -> SpanPrinter {
-        SpanPrinter { _priv: () }
+        SpanPrinter { lowercase: false }
+    }
+
+    /// Use lowercase for unit designator labels.
+    ///
+    /// By default, unit designator labels are written in uppercase.
+    pub(super) const fn lowercase(self, yes: bool) -> SpanPrinter {
+        SpanPrinter { lowercase: yes }
     }
 
     /// Print the given span to the writer given.
@@ -249,22 +256,22 @@ impl SpanPrinter {
         let mut non_zero_greater_than_second = false;
         if span.get_years_ranged() != 0 {
             wtr.write_int(&FMT_INT, span.get_years_ranged().get().abs())?;
-            wtr.write_str("y")?;
+            wtr.write_char(self.label('Y'))?;
             non_zero_greater_than_second = true;
         }
         if span.get_months_ranged() != 0 {
             wtr.write_int(&FMT_INT, span.get_months_ranged().get().abs())?;
-            wtr.write_str("m")?;
+            wtr.write_char(self.label('M'))?;
             non_zero_greater_than_second = true;
         }
         if span.get_weeks_ranged() != 0 {
             wtr.write_int(&FMT_INT, span.get_weeks_ranged().get().abs())?;
-            wtr.write_str("w")?;
+            wtr.write_char(self.label('W'))?;
             non_zero_greater_than_second = true;
         }
         if span.get_days_ranged() != 0 {
             wtr.write_int(&FMT_INT, span.get_days_ranged().get().abs())?;
-            wtr.write_str("d")?;
+            wtr.write_char(self.label('D'))?;
             non_zero_greater_than_second = true;
         }
 
@@ -275,7 +282,7 @@ impl SpanPrinter {
                 printed_time_prefix = true;
             }
             wtr.write_int(&FMT_INT, span.get_hours_ranged().get().abs())?;
-            wtr.write_str("h")?;
+            wtr.write_char(self.label('H'))?;
             non_zero_greater_than_second = true;
         }
         if span.get_minutes_ranged() != 0 {
@@ -284,7 +291,7 @@ impl SpanPrinter {
                 printed_time_prefix = true;
             }
             wtr.write_int(&FMT_INT, span.get_minutes_ranged().get().abs())?;
-            wtr.write_str("m")?;
+            wtr.write_char(self.label('M'))?;
             non_zero_greater_than_second = true;
         }
 
@@ -307,7 +314,7 @@ impl SpanPrinter {
                 wtr.write_str("T")?;
             }
             wtr.write_int(&FMT_INT, seconds.get())?;
-            wtr.write_str("s")?;
+            wtr.write_char(self.label('S'))?;
         } else if millis != 0 || micros != 0 || nanos != 0 {
             if !printed_time_prefix {
                 wtr.write_str("T")?;
@@ -336,7 +343,7 @@ impl SpanPrinter {
                 wtr.write_str(".")?;
                 wtr.write_fraction(&FMT_FRACTION, fraction_nano.get())?;
             }
-            wtr.write_str("s")?;
+            wtr.write_char(self.label('S'))?;
         }
         Ok(())
     }
@@ -370,25 +377,37 @@ impl SpanPrinter {
         secs = (secs % 60).abs();
         if hours != 0 {
             wtr.write_int(&FMT_INT, hours)?;
-            wtr.write_str("h")?;
+            wtr.write_char(self.label('H'))?;
             non_zero_greater_than_second = true;
         }
         if minutes != 0 {
             wtr.write_int(&FMT_INT, minutes)?;
-            wtr.write_str("m")?;
+            wtr.write_char(self.label('M'))?;
             non_zero_greater_than_second = true;
         }
         if (secs != 0 || !non_zero_greater_than_second) && nanos == 0 {
             wtr.write_int(&FMT_INT, secs)?;
-            wtr.write_str("s")?;
+            wtr.write_char(self.label('S'))?;
         } else if nanos != 0 {
             wtr.write_int(&FMT_INT, secs)?;
             wtr.write_str(".")?;
             wtr.write_fraction(&FMT_FRACTION, nanos)?;
-            wtr.write_str("s")?;
+            wtr.write_char(self.label('S'))?;
         }
         Ok(())
     }
+
+    /// Converts the uppercase unit designator label to lowercase if this
+    /// printer is configured to use lowercase. Otherwise the label is returned
+    /// unchanged.
+    fn label(&self, upper: char) -> char {
+        debug_assert!(upper.is_ascii());
+        if self.lowercase {
+            upper.to_ascii_lowercase()
+        } else {
+            upper
+        }
+    }
 }
 
 #[cfg(test)]
@@ -450,25 +469,25 @@ mod tests {
             buf
         };
 
-        insta::assert_snapshot!(p(Span::new()), @"PT0s");
-        insta::assert_snapshot!(p(1.second()), @"PT1s");
-        insta::assert_snapshot!(p(-1.second()), @"-PT1s");
+        insta::assert_snapshot!(p(Span::new()), @"PT0S");
+        insta::assert_snapshot!(p(1.second()), @"PT1S");
+        insta::assert_snapshot!(p(-1.second()), @"-PT1S");
         insta::assert_snapshot!(p(
             1.second().milliseconds(1).microseconds(1).nanoseconds(1),
-        ), @"PT1.001001001s");
+        ), @"PT1.001001001S");
         insta::assert_snapshot!(p(
             0.second().milliseconds(999).microseconds(999).nanoseconds(999),
-        ), @"PT0.999999999s");
+        ), @"PT0.999999999S");
         insta::assert_snapshot!(p(
             1.year().months(1).weeks(1).days(1)
             .hours(1).minutes(1).seconds(1)
             .milliseconds(1).microseconds(1).nanoseconds(1),
-        ), @"P1y1m1w1dT1h1m1.001001001s");
+        ), @"P1Y1M1W1DT1H1M1.001001001S");
         insta::assert_snapshot!(p(
             -1.year().months(1).weeks(1).days(1)
             .hours(1).minutes(1).seconds(1)
             .milliseconds(1).microseconds(1).nanoseconds(1),
-        ), @"-P1y1m1w1dT1h1m1.001001001s");
+        ), @"-P1Y1M1W1DT1H1M1.001001001S");
     }
 
     #[test]
@@ -482,52 +501,52 @@ mod tests {
         // These are all sub-second trickery tests.
         insta::assert_snapshot!(p(
             0.second().milliseconds(1000).microseconds(1000).nanoseconds(1000),
-        ), @"PT1.001001s");
+        ), @"PT1.001001S");
         insta::assert_snapshot!(p(
             1.second().milliseconds(1000).microseconds(1000).nanoseconds(1000),
-        ), @"PT2.001001s");
+        ), @"PT2.001001S");
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MAX_REPR),
-        ), @"PT631107417600s");
+        ), @"PT631107417600S");
         insta::assert_snapshot!(p(
             0.second()
             .microseconds(t::SpanMicroseconds::MAX_REPR),
-        ), @"PT631107417600s");
+        ), @"PT631107417600S");
         insta::assert_snapshot!(p(
             0.second()
             .nanoseconds(t::SpanNanoseconds::MAX_REPR),
-        ), @"PT9223372036.854775807s");
+        ), @"PT9223372036.854775807S");
 
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MAX_REPR)
             .microseconds(999_999),
-        ), @"PT631107417600.999999s");
+        ), @"PT631107417600.999999S");
         // This is 1 microsecond more than the maximum number of seconds
         // representable in a span.
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MAX_REPR)
             .microseconds(1_000_000),
-        ), @"PT631107417601s");
+        ), @"PT631107417601S");
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MAX_REPR)
             .microseconds(1_000_001),
-        ), @"PT631107417601.000001s");
+        ), @"PT631107417601.000001S");
         // This is 1 nanosecond more than the maximum number of seconds
         // representable in a span.
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MAX_REPR)
             .nanoseconds(1_000_000_000),
-        ), @"PT631107417601s");
+        ), @"PT631107417601S");
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MAX_REPR)
             .nanoseconds(1_000_000_001),
-        ), @"PT631107417601.000000001s");
+        ), @"PT631107417601.000000001S");
 
         // The max millis, micros and nanos, combined.
         insta::assert_snapshot!(p(
@@ -535,7 +554,7 @@ mod tests {
             .milliseconds(t::SpanMilliseconds::MAX_REPR)
             .microseconds(t::SpanMicroseconds::MAX_REPR)
             .nanoseconds(t::SpanNanoseconds::MAX_REPR),
-        ), @"PT1271438207236.854775807s");
+        ), @"PT1271438207236.854775807S");
         // The max seconds, millis, micros and nanos, combined.
         insta::assert_snapshot!(p(
             Span::new()
@@ -543,7 +562,7 @@ mod tests {
             .milliseconds(t::SpanMilliseconds::MAX_REPR)
             .microseconds(t::SpanMicroseconds::MAX_REPR)
             .nanoseconds(t::SpanNanoseconds::MAX_REPR),
-        ), @"PT1902545624836.854775807s");
+        ), @"PT1902545624836.854775807S");
     }
 
     #[test]
@@ -557,52 +576,52 @@ mod tests {
         // These are all sub-second trickery tests.
         insta::assert_snapshot!(p(
             -0.second().milliseconds(1000).microseconds(1000).nanoseconds(1000),
-        ), @"-PT1.001001s");
+        ), @"-PT1.001001S");
         insta::assert_snapshot!(p(
             -1.second().milliseconds(1000).microseconds(1000).nanoseconds(1000),
-        ), @"-PT2.001001s");
+        ), @"-PT2.001001S");
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MIN_REPR),
-        ), @"-PT631107417600s");
+        ), @"-PT631107417600S");
         insta::assert_snapshot!(p(
             0.second()
             .microseconds(t::SpanMicroseconds::MIN_REPR),
-        ), @"-PT631107417600s");
+        ), @"-PT631107417600S");
         insta::assert_snapshot!(p(
             0.second()
             .nanoseconds(t::SpanNanoseconds::MIN_REPR),
-        ), @"-PT9223372036.854775807s");
+        ), @"-PT9223372036.854775807S");
 
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MIN_REPR)
             .microseconds(999_999),
-        ), @"-PT631107417600.999999s");
+        ), @"-PT631107417600.999999S");
         // This is 1 microsecond more than the maximum number of seconds
         // representable in a span.
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MIN_REPR)
             .microseconds(1_000_000),
-        ), @"-PT631107417601s");
+        ), @"-PT631107417601S");
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MIN_REPR)
             .microseconds(1_000_001),
-        ), @"-PT631107417601.000001s");
+        ), @"-PT631107417601.000001S");
         // This is 1 nanosecond more than the maximum number of seconds
         // representable in a span.
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MIN_REPR)
             .nanoseconds(1_000_000_000),
-        ), @"-PT631107417601s");
+        ), @"-PT631107417601S");
         insta::assert_snapshot!(p(
             0.second()
             .milliseconds(t::SpanMilliseconds::MIN_REPR)
             .nanoseconds(1_000_000_001),
-        ), @"-PT631107417601.000000001s");
+        ), @"-PT631107417601.000000001S");
 
         // The max millis, micros and nanos, combined.
         insta::assert_snapshot!(p(
@@ -610,7 +629,7 @@ mod tests {
             .milliseconds(t::SpanMilliseconds::MIN_REPR)
             .microseconds(t::SpanMicroseconds::MIN_REPR)
             .nanoseconds(t::SpanNanoseconds::MIN_REPR),
-        ), @"-PT1271438207236.854775807s");
+        ), @"-PT1271438207236.854775807S");
         // The max seconds, millis, micros and nanos, combined.
         insta::assert_snapshot!(p(
             Span::new()
@@ -618,7 +637,7 @@ mod tests {
             .milliseconds(t::SpanMilliseconds::MIN_REPR)
             .microseconds(t::SpanMicroseconds::MIN_REPR)
             .nanoseconds(t::SpanNanoseconds::MIN_REPR),
-        ), @"-PT1902545624836.854775807s");
+        ), @"-PT1902545624836.854775807S");
     }
 
     #[test]
@@ -630,40 +649,40 @@ mod tests {
             buf
         };
 
-        insta::assert_snapshot!(p(0, 0), @"PT0s");
-        insta::assert_snapshot!(p(0, 1), @"PT0.000000001s");
-        insta::assert_snapshot!(p(1, 0), @"PT1s");
-        insta::assert_snapshot!(p(59, 0), @"PT59s");
-        insta::assert_snapshot!(p(60, 0), @"PT1m");
-        insta::assert_snapshot!(p(60, 1), @"PT1m0.000000001s");
-        insta::assert_snapshot!(p(61, 1), @"PT1m1.000000001s");
-        insta::assert_snapshot!(p(3_600, 0), @"PT1h");
-        insta::assert_snapshot!(p(3_600, 1), @"PT1h0.000000001s");
-        insta::assert_snapshot!(p(3_660, 0), @"PT1h1m");
-        insta::assert_snapshot!(p(3_660, 1), @"PT1h1m0.000000001s");
-        insta::assert_snapshot!(p(3_661, 0), @"PT1h1m1s");
-        insta::assert_snapshot!(p(3_661, 1), @"PT1h1m1.000000001s");
-
-        insta::assert_snapshot!(p(0, -1), @"-PT0.000000001s");
-        insta::assert_snapshot!(p(-1, 0), @"-PT1s");
-        insta::assert_snapshot!(p(-59, 0), @"-PT59s");
-        insta::assert_snapshot!(p(-60, 0), @"-PT1m");
-        insta::assert_snapshot!(p(-60, -1), @"-PT1m0.000000001s");
-        insta::assert_snapshot!(p(-61, -1), @"-PT1m1.000000001s");
-        insta::assert_snapshot!(p(-3_600, 0), @"-PT1h");
-        insta::assert_snapshot!(p(-3_600, -1), @"-PT1h0.000000001s");
-        insta::assert_snapshot!(p(-3_660, 0), @"-PT1h1m");
-        insta::assert_snapshot!(p(-3_660, -1), @"-PT1h1m0.000000001s");
-        insta::assert_snapshot!(p(-3_661, 0), @"-PT1h1m1s");
-        insta::assert_snapshot!(p(-3_661, -1), @"-PT1h1m1.000000001s");
+        insta::assert_snapshot!(p(0, 0), @"PT0S");
+        insta::assert_snapshot!(p(0, 1), @"PT0.000000001S");
+        insta::assert_snapshot!(p(1, 0), @"PT1S");
+        insta::assert_snapshot!(p(59, 0), @"PT59S");
+        insta::assert_snapshot!(p(60, 0), @"PT1M");
+        insta::assert_snapshot!(p(60, 1), @"PT1M0.000000001S");
+        insta::assert_snapshot!(p(61, 1), @"PT1M1.000000001S");
+        insta::assert_snapshot!(p(3_600, 0), @"PT1H");
+        insta::assert_snapshot!(p(3_600, 1), @"PT1H0.000000001S");
+        insta::assert_snapshot!(p(3_660, 0), @"PT1H1M");
+        insta::assert_snapshot!(p(3_660, 1), @"PT1H1M0.000000001S");
+        insta::assert_snapshot!(p(3_661, 0), @"PT1H1M1S");
+        insta::assert_snapshot!(p(3_661, 1), @"PT1H1M1.000000001S");
+
+        insta::assert_snapshot!(p(0, -1), @"-PT0.000000001S");
+        insta::assert_snapshot!(p(-1, 0), @"-PT1S");
+        insta::assert_snapshot!(p(-59, 0), @"-PT59S");
+        insta::assert_snapshot!(p(-60, 0), @"-PT1M");
+        insta::assert_snapshot!(p(-60, -1), @"-PT1M0.000000001S");
+        insta::assert_snapshot!(p(-61, -1), @"-PT1M1.000000001S");
+        insta::assert_snapshot!(p(-3_600, 0), @"-PT1H");
+        insta::assert_snapshot!(p(-3_600, -1), @"-PT1H0.000000001S");
+        insta::assert_snapshot!(p(-3_660, 0), @"-PT1H1M");
+        insta::assert_snapshot!(p(-3_660, -1), @"-PT1H1M0.000000001S");
+        insta::assert_snapshot!(p(-3_661, 0), @"-PT1H1M1S");
+        insta::assert_snapshot!(p(-3_661, -1), @"-PT1H1M1.000000001S");
 
         insta::assert_snapshot!(
             p(i64::MIN, -999_999_999),
-            @"-PT2562047788015215h30m8.999999999s",
+            @"-PT2562047788015215H30M8.999999999S",
         );
         insta::assert_snapshot!(
             p(i64::MAX, 999_999_999),
-            @"PT2562047788015215h30m7.999999999s",
+            @"PT2562047788015215H30M7.999999999S",
         );
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index bea9dc3a..79b9392f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -368,7 +368,7 @@ use jiff::civil::date;
 let zdt1 = date(2020, 8, 26).at(6, 27, 0, 0).intz("America/New_York")?;
 let zdt2 = date(2023, 12, 31).at(18, 30, 0, 0).intz("America/New_York")?;
 let span = &zdt2 - &zdt1;
-assert_eq!(span.to_string(), "PT29341h3m");
+assert_eq!(format!("{span:#}"), "29341h 3m");
 
 # Ok::<(), Box<dyn std::error::Error>>(())
 ```
@@ -384,7 +384,7 @@ use jiff::{civil::date, Unit};
 let zdt1 = date(2020, 8, 26).at(6, 27, 0, 0).intz("America/New_York")?;
 let zdt2 = date(2023, 12, 31).at(18, 30, 0, 0).intz("America/New_York")?;
 let span = zdt1.until((Unit::Year, &zdt2))?;
-assert_eq!(span.to_string(), "P3y4m5dT12h3m");
+assert_eq!(format!("{span:#}"), "3y 4mo 5d 12h 3m");
 
 # Ok::<(), Box<dyn std::error::Error>>(())
 ```
diff --git a/src/signed_duration.rs b/src/signed_duration.rs
index c0cac5b2..b5681873 100644
--- a/src/signed_duration.rs
+++ b/src/signed_duration.rs
@@ -32,7 +32,7 @@ use crate::util::libm::Float;
 /// use jiff::SignedDuration;
 ///
 /// let duration: SignedDuration = "PT2h30m".parse()?;
-/// assert_eq!(duration.to_string(), "PT2h30m");
+/// assert_eq!(duration.to_string(), "PT2H30M");
 ///
 /// // Or use the "friendly" format by invoking the alternate:
 /// assert_eq!(format!("{duration:#}"), "2h 30m");
@@ -75,7 +75,7 @@ use crate::util::libm::Float;
 /// let duration = span.to_jiff_duration(&relative)?;
 /// // This example also motivates *why* a relative date
 /// // is required. Not all days are the same length!
-/// assert_eq!(duration.to_string(), "PT25h");
+/// assert_eq!(duration.to_string(), "PT25H");
 ///
 /// # Ok::<(), Box<dyn std::error::Error>>(())
 /// ```
@@ -2641,27 +2641,27 @@ mod tests {
 
         insta::assert_snapshot!(
             p("1 hour").unwrap(),
-            @"PT1h",
+            @"PT1H",
         );
         insta::assert_snapshot!(
             p("+1 hour").unwrap(),
-            @"PT1h",
+            @"PT1H",
         );
         insta::assert_snapshot!(
             p("-1 hour").unwrap(),
-            @"-PT1h",
+            @"-PT1H",
         );
         insta::assert_snapshot!(
             p("PT1h").unwrap(),
-            @"PT1h",
+            @"PT1H",
         );
         insta::assert_snapshot!(
             p("+PT1h").unwrap(),
-            @"PT1h",
+            @"PT1H",
         );
         insta::assert_snapshot!(
             p("-PT1h").unwrap(),
-            @"-PT1h",
+            @"-PT1H",
         );
 
         insta::assert_snapshot!(
@@ -2686,27 +2686,27 @@ mod tests {
 
         insta::assert_snapshot!(
             p("1 hour").unwrap(),
-            @"PT1h",
+            @"PT1H",
         );
         insta::assert_snapshot!(
             p("+1 hour").unwrap(),
-            @"PT1h",
+            @"PT1H",
         );
         insta::assert_snapshot!(
             p("-1 hour").unwrap(),
-            @"-PT1h",
+            @"-PT1H",
         );
         insta::assert_snapshot!(
             p("PT1h").unwrap(),
-            @"PT1h",
+            @"PT1H",
         );
         insta::assert_snapshot!(
             p("+PT1h").unwrap(),
-            @"PT1h",
+            @"PT1H",
         );
         insta::assert_snapshot!(
             p("-PT1h").unwrap(),
-            @"-PT1h",
+            @"-PT1H",
         );
 
         insta::assert_snapshot!(
diff --git a/src/span.rs b/src/span.rs
index a901557c..e8c7b216 100644
--- a/src/span.rs
+++ b/src/span.rs
@@ -70,7 +70,7 @@ use crate::{
 /// use jiff::Span;
 ///
 /// let span = Span::new().days(5).hours(8).minutes(1);
-/// assert_eq!(span.to_string(), "P5dT8h1m");
+/// assert_eq!(span.to_string(), "P5DT8H1M");
 /// ```
 ///
 /// But Jiff provides a [`ToSpan`] trait that defines extension methods on
@@ -80,10 +80,10 @@ use crate::{
 /// use jiff::ToSpan;
 ///
 /// let span = 5.days().hours(8).minutes(1);
-/// assert_eq!(span.to_string(), "P5dT8h1m");
+/// assert_eq!(span.to_string(), "P5DT8H1M");
 /// // singular units on integers can be used too:
 /// let span = 1.day().hours(8).minutes(1);
-/// assert_eq!(span.to_string(), "P1dT8h1m");
+/// assert_eq!(span.to_string(), "P1DT8H1M");
 /// ```
 ///
 /// # Negative spans
@@ -99,25 +99,25 @@ use crate::{
 /// use jiff::{Span, ToSpan};
 ///
 /// let span = -Span::new().days(5);
-/// assert_eq!(span.to_string(), "-P5d");
+/// assert_eq!(span.to_string(), "-P5D");
 ///
 /// let span = Span::new().days(5).negate();
-/// assert_eq!(span.to_string(), "-P5d");
+/// assert_eq!(span.to_string(), "-P5D");
 ///
 /// let span = Span::new().days(-5);
-/// assert_eq!(span.to_string(), "-P5d");
+/// assert_eq!(span.to_string(), "-P5D");
 ///
 /// let span = -Span::new().days(-5).negate();
-/// assert_eq!(span.to_string(), "-P5d");
+/// assert_eq!(span.to_string(), "-P5D");
 ///
 /// let span = -5.days();
-/// assert_eq!(span.to_string(), "-P5d");
+/// assert_eq!(span.to_string(), "-P5D");
 ///
 /// let span = (-5).days();
-/// assert_eq!(span.to_string(), "-P5d");
+/// assert_eq!(span.to_string(), "-P5D");
 ///
 /// let span = -(5.days());
-/// assert_eq!(span.to_string(), "-P5d");
+/// assert_eq!(span.to_string(), "-P5D");
 /// ```
 ///
 /// The sign of a span applies to the entire span. When a span is negative,
@@ -180,10 +180,12 @@ use crate::{
 /// ```
 /// use jiff::{Span, ToSpan};
 ///
-/// let span: Span = "P2M10DT2H30M".parse()?;
-/// assert_eq!(span.to_string(), "P2m10dT2h30m");
+/// let span: Span = "P2m10dT2h30m".parse()?;
+/// // By default, capital unit designator labels are used.
+/// // This can be changed with `jiff::fmt::temporal::SpanPrinter::lowercase`.
+/// assert_eq!(span.to_string(), "P2M10DT2H30M");
 ///
-/// // Or use the "friendly" format by invoking the alternate:
+/// // Or use the "friendly" format by invoking the `Display` alternate:
 /// assert_eq!(format!("{span:#}"), "2mo 10d 2h 30m");
 ///
 /// // Parsing automatically supports both the ISO 8601 and "friendly" formats:
@@ -1227,9 +1229,9 @@ impl Span {
     /// use jiff::ToSpan;
     ///
     /// let span = -100.seconds();
-    /// assert_eq!(span.to_string(), "-PT100s");
+    /// assert_eq!(span.to_string(), "-PT100S");
     /// let span = span.abs();
-    /// assert_eq!(span.to_string(), "PT100s");
+    /// assert_eq!(span.to_string(), "PT100S");
     /// ```
     #[inline]
     pub fn abs(self) -> Span {
@@ -1251,9 +1253,9 @@ impl Span {
     /// use jiff::ToSpan;
     ///
     /// let span = 100.days();
-    /// assert_eq!(span.to_string(), "P100d");
+    /// assert_eq!(span.to_string(), "P100D");
     /// let span = span.negate();
-    /// assert_eq!(span.to_string(), "-P100d");
+    /// assert_eq!(span.to_string(), "-P100D");
     /// ```
     ///
     /// # Example: available via the negation operator
@@ -1264,9 +1266,9 @@ impl Span {
     /// use jiff::ToSpan;
     ///
     /// let span = 100.days();
-    /// assert_eq!(span.to_string(), "P100d");
+    /// assert_eq!(span.to_string(), "P100D");
     /// let span = -span;
-    /// assert_eq!(span.to_string(), "-P100d");
+    /// assert_eq!(span.to_string(), "-P100D");
     /// ```
     #[inline]
     pub fn negate(self) -> Span {
@@ -3708,13 +3710,13 @@ impl quickcheck::Arbitrary for Span {
 /// ```
 /// use jiff::ToSpan;
 ///
-/// assert_eq!(5.days().to_string(), "P5d");
-/// assert_eq!(5.days().hours(10).to_string(), "P5dT10h");
+/// assert_eq!(5.days().to_string(), "P5D");
+/// assert_eq!(5.days().hours(10).to_string(), "P5DT10H");
 ///
 /// // Negation works and it doesn't matter where the sign goes. It can be
 /// // applied to the span itself or to the integer.
-/// assert_eq!((-5.days()).to_string(), "-P5d");
-/// assert_eq!((-5).days().to_string(), "-P5d");
+/// assert_eq!((-5.days()).to_string(), "-P5D");
+/// assert_eq!((-5).days().to_string(), "-P5D");
 /// ```
 ///
 /// # Example: alternative via span parsing
@@ -3929,7 +3931,7 @@ impl_to_span!(i64);
 /// let zdt1: Zoned = "2024-07-06 17:40-04[America/New_York]".parse()?;
 /// let zdt2: Zoned = "2024-11-05 08:00-05[America/New_York]".parse()?;
 /// let span = zdt1.until((Unit::Year, &zdt2))?;
-/// assert_eq!(span.to_string(), "P3m29dT14h20m");
+/// assert_eq!(format!("{span:#}"), "3mo 29d 14h 20m");
 ///
 /// # Ok::<(), Box<dyn std::error::Error>>(())
 /// ```
@@ -6507,7 +6509,7 @@ mod tests {
             .nanoseconds(10);
         insta::assert_snapshot!(
             span,
-            @"P1y2m3w4dT5h6m7.00800901s",
+            @"P1Y2M3W4DT5H6M7.00800901S",
         );
         insta::assert_snapshot!(
             alloc::format!("{span:#}"),
@@ -6575,27 +6577,27 @@ mod tests {
 
         insta::assert_snapshot!(
             p("1 day").unwrap(),
-            @"P1d",
+            @"P1D",
         );
         insta::assert_snapshot!(
             p("+1 day").unwrap(),
-            @"P1d",
+            @"P1D",
         );
         insta::assert_snapshot!(
             p("-1 day").unwrap(),
-            @"-P1d",
+            @"-P1D",
         );
         insta::assert_snapshot!(
             p("P1d").unwrap(),
-            @"P1d",
+            @"P1D",
         );
         insta::assert_snapshot!(
             p("+P1d").unwrap(),
-            @"P1d",
+            @"P1D",
         );
         insta::assert_snapshot!(
             p("-P1d").unwrap(),
-            @"-P1d",
+            @"-P1D",
         );
 
         insta::assert_snapshot!(
@@ -6620,27 +6622,27 @@ mod tests {
 
         insta::assert_snapshot!(
             p("1 day").unwrap(),
-            @"P1d",
+            @"P1D",
         );
         insta::assert_snapshot!(
             p("+1 day").unwrap(),
-            @"P1d",
+            @"P1D",
         );
         insta::assert_snapshot!(
             p("-1 day").unwrap(),
-            @"-P1d",
+            @"-P1D",
         );
         insta::assert_snapshot!(
             p("P1d").unwrap(),
-            @"P1d",
+            @"P1D",
         );
         insta::assert_snapshot!(
             p("+P1d").unwrap(),
-            @"P1d",
+            @"P1D",
         );
         insta::assert_snapshot!(
             p("-P1d").unwrap(),
-            @"-P1d",
+            @"-P1D",
         );
 
         insta::assert_snapshot!(
diff --git a/src/timestamp.rs b/src/timestamp.rs
index 3fb0f093..316ab33c 100644
--- a/src/timestamp.rs
+++ b/src/timestamp.rs
@@ -1521,11 +1521,11 @@ impl Timestamp {
     ///
     /// // The default limits durations to using "seconds" as the biggest unit.
     /// let span = ts1.until(ts2)?;
-    /// assert_eq!(span.to_string(), "PT730641929.9999965s");
+    /// assert_eq!(span.to_string(), "PT730641929.9999965S");
     ///
     /// // But we can ask for units all the way up to hours.
     /// let span = ts1.until((Unit::Hour, ts2))?;
-    /// assert_eq!(span.to_string(), "PT202956h5m29.9999965s");
+    /// assert_eq!(span.to_string(), "PT202956H5M29.9999965S");
     ///
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
diff --git a/src/zoned.rs b/src/zoned.rs
index d17a62ee..2ae7fd27 100644
--- a/src/zoned.rs
+++ b/src/zoned.rs
@@ -2366,11 +2366,11 @@ impl Zoned {
     ///
     /// // The default limits durations to using "hours" as the biggest unit.
     /// let span = zdt1.until(&zdt2)?;
-    /// assert_eq!(span.to_string(), "PT202956h5m29.9999965s");
+    /// assert_eq!(span.to_string(), "PT202956H5M29.9999965S");
     ///
     /// // But we can ask for units all the way up to years.
     /// let span = zdt1.until((Unit::Year, &zdt2))?;
-    /// assert_eq!(span.to_string(), "P23y1m24dT12h5m29.9999965s");
+    /// assert_eq!(span.to_string(), "P23Y1M24DT12H5M29.9999965S");
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     ///
diff --git a/tests/tc39_262/civil/datetime/until.rs b/tests/tc39_262/civil/datetime/until.rs
index 3d50d334..78e27477 100644
--- a/tests/tc39_262/civil/datetime/until.rs
+++ b/tests/tc39_262/civil/datetime/until.rs
@@ -88,15 +88,15 @@ fn balance() -> Result {
     let c: DateTime = "2021-03-05T09:32:45+00:00[UTC]".parse()?;
 
     let span = a.until((Unit::Month, b))?;
-    assert_eq!(span.to_string(), "P40m27dT19h25m31s");
+    assert_eq!(span.to_string(), "P40M27DT19H25M31S");
     assert_eq!(a + span, b);
 
     let span = b.until((Unit::Month, a))?;
-    assert_eq!(span.to_string(), "-P40m30dT19h25m31s");
+    assert_eq!(span.to_string(), "-P40M30DT19H25M31S");
     assert_eq!(b + span, a);
 
     let span = c.until((Unit::Month, a))?;
-    assert_eq!(span.to_string(), "-P41mT1h25m31s");
+    assert_eq!(span.to_string(), "-P41MT1H25M31S");
     assert_eq!(c + span, a);
 
     Ok(())
@@ -474,8 +474,8 @@ fn weeks_months_mutually_exclusive() -> Result {
     let dt1 = date(1976, 11, 18).at(15, 23, 30, 123_456_789);
     let dt2 = dt1 + 42.days().hours(3);
 
-    assert_eq!(dt1.until((Unit::Week, dt2))?.to_string(), "P6wT3h");
-    assert_eq!(dt1.until((Unit::Month, dt2))?.to_string(), "P1m12dT3h");
+    assert_eq!(dt1.until((Unit::Week, dt2))?.to_string(), "P6WT3H");
+    assert_eq!(dt1.until((Unit::Month, dt2))?.to_string(), "P1M12DT3H");
     Ok(())
 }
 
diff --git a/tests/tc39_262/civil/time/until.rs b/tests/tc39_262/civil/time/until.rs
index 9c39dc32..e110251c 100644
--- a/tests/tc39_262/civil/time/until.rs
+++ b/tests/tc39_262/civil/time/until.rs
@@ -27,22 +27,22 @@ fn balance_negative_time_units() -> Result {
     let t2 = time(1, 1, 1, 001_001_001);
 
     let t1 = time(0, 0, 0, 000_000_002);
-    assert_eq!(t1.until(t2)?.to_string(), "PT1h1m1.001000999s");
+    assert_eq!(t1.until(t2)?.to_string(), "PT1H1M1.001000999S");
 
     let t1 = time(0, 0, 0, 000_002_000);
-    assert_eq!(t1.until(t2)?.to_string(), "PT1h1m1.000999001s");
+    assert_eq!(t1.until(t2)?.to_string(), "PT1H1M1.000999001S");
 
     let t1 = time(0, 0, 0, 002_000_000);
-    assert_eq!(t1.until(t2)?.to_string(), "PT1h1m0.999001001s");
+    assert_eq!(t1.until(t2)?.to_string(), "PT1H1M0.999001001S");
 
     let t1 = time(0, 0, 2, 0);
-    assert_eq!(t1.until(t2)?.to_string(), "PT1h59.001001001s");
+    assert_eq!(t1.until(t2)?.to_string(), "PT1H59.001001001S");
 
     let t1 = time(0, 2, 0, 0);
-    assert_eq!(t1.until(t2)?.to_string(), "PT59m1.001001001s");
+    assert_eq!(t1.until(t2)?.to_string(), "PT59M1.001001001S");
 
     let t1 = time(2, 0, 0, 0);
-    assert_eq!(t1.until(t2)?.to_string(), "-PT58m58.998998999s");
+    assert_eq!(t1.until(t2)?.to_string(), "-PT58M58.998998999S");
 
     Ok(())
 }
@@ -54,10 +54,10 @@ fn basic() -> Result {
     let two = time(16, 23, 30, 123_456_789);
     let three = time(17, 0, 30, 123_456_789);
 
-    assert_eq!(one.until(two)?.to_string(), "PT1h");
-    assert_eq!(two.until(one)?.to_string(), "-PT1h");
-    assert_eq!(one.until(three)?.to_string(), "PT1h37m");
-    assert_eq!(three.until(one)?.to_string(), "-PT1h37m");
+    assert_eq!(one.until(two)?.to_string(), "PT1H");
+    assert_eq!(two.until(one)?.to_string(), "-PT1H");
+    assert_eq!(one.until(three)?.to_string(), "PT1H37M");
+    assert_eq!(three.until(one)?.to_string(), "-PT1H37M");
 
     Ok(())
 }
@@ -109,10 +109,10 @@ fn largestunit() -> Result {
     let t1 = time(4, 48, 55, 0);
     let t2 = time(11, 59, 58, 0);
 
-    assert_eq!(t1.until(t2)?.to_string(), "PT7h11m3s");
-    assert_eq!(t1.until((Unit::Hour, t2))?.to_string(), "PT7h11m3s");
-    assert_eq!(t1.until((Unit::Minute, t2))?.to_string(), "PT431m3s");
-    assert_eq!(t1.until((Unit::Second, t2))?.to_string(), "PT25863s");
+    assert_eq!(t1.until(t2)?.to_string(), "PT7H11M3S");
+    assert_eq!(t1.until((Unit::Hour, t2))?.to_string(), "PT7H11M3S");
+    assert_eq!(t1.until((Unit::Minute, t2))?.to_string(), "PT431M3S");
+    assert_eq!(t1.until((Unit::Second, t2))?.to_string(), "PT25863S");
 
     Ok(())
 }
@@ -132,7 +132,7 @@ fn result_sub_second() -> Result {
     // via fractional seconds.)
     assert_eq!(
         t1.until((Unit::Millisecond, t2))?.to_string(),
-        "PT24762.25025025s",
+        "PT24762.25025025S",
     );
 
     assert_eq!(
@@ -141,7 +141,7 @@ fn result_sub_second() -> Result {
     );
     assert_eq!(
         t1.until((Unit::Microsecond, t2))?.to_string(),
-        "PT24762.25025025s",
+        "PT24762.25025025S",
     );
 
     assert_eq!(
@@ -150,7 +150,7 @@ fn result_sub_second() -> Result {
     );
     assert_eq!(
         t1.until((Unit::Nanosecond, t2))?.to_string(),
-        "PT24762.25025025s",
+        "PT24762.25025025S",
     );
 
     Ok(())
diff --git a/tests/tc39_262/span/round.rs b/tests/tc39_262/span/round.rs
index 949f383e..6b26063f 100644
--- a/tests/tc39_262/span/round.rs
+++ b/tests/tc39_262/span/round.rs
@@ -210,14 +210,14 @@ fn duration_out_of_range_added_to_relative() -> Result {
     let relative = SpanRound::new().relative(d);
     insta::assert_snapshot!(
         sp.round(relative.smallest(Unit::Year)).unwrap_err(),
-        @"failed to add P2000000dT170000000h to 2000-01-01T00:00:00: failed to add overflowing span, P7083333d, from adding PT170000000h to 00:00:00, to 7475-10-25: parameter 'days' with value 7083333 is not in the required range of -4371587..=2932896",
+        @"failed to add P2000000DT170000000H to 2000-01-01T00:00:00: failed to add overflowing span, P7083333D, from adding PT170000000H to 00:00:00, to 7475-10-25: parameter 'days' with value 7083333 is not in the required range of -4371587..=2932896",
     );
 
     let sp = -2_000_000.days().hours(170_000_000);
     let relative = SpanRound::new().relative(d);
     insta::assert_snapshot!(
         sp.round(relative.smallest(Unit::Year)).unwrap_err(),
-        @"failed to add -P2000000dT170000000h to 2000-01-01T00:00:00: failed to add overflowing span, -P7083334d, from adding -PT170000000h to 00:00:00, to -003476-03-09: parameter 'days' with value -7083334 is not in the required range of -4371587..=2932896",
+        @"failed to add -P2000000DT170000000H to 2000-01-01T00:00:00: failed to add overflowing span, -P7083334D, from adding -PT170000000H to 00:00:00, to -003476-03-09: parameter 'days' with value -7083334 is not in the required range of -4371587..=2932896",
     );
 
     Ok(())
@@ -611,7 +611,7 @@ fn out_of_range_when_adjusting_rounded_days() -> Result {
     insta::assert_snapshot!(
         sp.round(options).unwrap_err(),
         // Kind of a brutal error message...
-        @"failed to add P1dT631107331200.999999999s to 1970-01-01T00:00:00+00:00[UTC]: failed to add span PT631107331200.999999999s to timestamp 1970-01-02T00:00:00Z (which was created from 1970-01-02T00:00:00): adding PT631107331200.999999999s to 1970-01-02T00:00:00Z overflowed: parameter 'span' with value 631107331200999999999 is not in the required range of -377705023201000000000..=253402207200999999999",
+        @"failed to add P1DT631107331200.999999999S to 1970-01-01T00:00:00+00:00[UTC]: failed to add span PT631107331200.999999999S to timestamp 1970-01-02T00:00:00Z (which was created from 1970-01-02T00:00:00): adding PT631107331200.999999999S to 1970-01-02T00:00:00Z overflowed: parameter 'span' with value 631107331200999999999 is not in the required range of -377705023201000000000..=253402207200999999999",
     );
 
     Ok(())

From 68e9727eac38b71e43d52e3e04fc6954850b4156 Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Thu, 2 Jan 2025 09:43:48 -0500
Subject: [PATCH 2/9] changelog: fix issue number reference

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8b8fabe..d00cce6a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,7 +15,7 @@ Bug fixes:
 
 * [#155](https://github.com/BurntSushi/jiff/issues/155):
 Relax `strftime` format strings from ASCII-only to all of UTF-8.
-* [#188](https://github.com/BurntSushi/jiff/issues/188):
+* [#190](https://github.com/BurntSushi/jiff/issues/190):
 `Span` and `SignedDuration` now use uppercase unit designator labels in their
 default ISO 8601 `Display` implementation.
 

From 72bc143b67229832de2cca444cc4395c05b64ecf Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Thu, 2 Jan 2025 11:02:27 -0500
Subject: [PATCH 3/9] changelog: 0.1.19

---
 CHANGELOG.md | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d00cce6a..3b72000a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,18 @@
 # CHANGELOG
 
-0.1.19 (TBD)
-============
-TODO
+0.1.19 (2025-01-02)
+===================
+This releases includes a UTF-8 related bug fix and a few enhancements.
+
+Firstly, a `Span`'s default `Display` implementation now writes uppercase
+unit designator labels. That means you'll get `P1Y2M3DT4H5M6S` instead
+of `P1y2m3dT4h5m6s` by default. You can restore previous behavior via
+`jiff::fmt::temporal::SpanPrinter::lowercase`. This change was made to improve
+interoperability.
+
+Secondly, `SignedDuration` now supports rounding via `SignedDuration::round`.
+Note that it only supports rounding time units (hours or smaller). In order to
+round with calendar units, you'll still need to use a `Span`.
 
 Enhancements:
 
@@ -10,14 +20,14 @@ Enhancements:
 Document value ranges for methods like `year`, `day`, `hour` and so on.
 * [#187](https://github.com/BurntSushi/jiff/issues/187):
 Add a rounding API (for time units only) on `SignedDuration`.
+* [#190](https://github.com/BurntSushi/jiff/issues/190):
+`Span` and `SignedDuration` now use uppercase unit designator labels in their
+default ISO 8601 `Display` implementation.
 
 Bug fixes:
 
 * [#155](https://github.com/BurntSushi/jiff/issues/155):
 Relax `strftime` format strings from ASCII-only to all of UTF-8.
-* [#190](https://github.com/BurntSushi/jiff/issues/190):
-`Span` and `SignedDuration` now use uppercase unit designator labels in their
-default ISO 8601 `Display` implementation.
 
 
 0.1.18 (2024-12-31)

From 4ea5eff1fee78c030349eeb5f5396e880c8b0ede Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Thu, 2 Jan 2025 11:02:29 -0500
Subject: [PATCH 4/9] 0.1.19

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 863ca1c2..3bc27d81 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "jiff"
-version = "0.1.18"  #:version
+version = "0.1.19"  #:version
 authors = ["Andrew Gallant <jamslam@gmail.com>"]
 license = "Unlicense OR MIT"
 repository = "https://github.com/BurntSushi/jiff"

From 21be4d209c10e88f92a00f6f722e7f264cce2ec2 Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Thu, 2 Jan 2025 09:44:38 -0500
Subject: [PATCH 5/9] fmt/temporal: add new `Pieces` type for granular ISO 8601
 parsing

This commit adds a new type to the `jiff::fmt::temporal` module that
exposes the raw components of a parsed Temporal ISO 8601 datetime
string.

This is meant to address use cases that need something a bit more
flexible than what is provided by the higher level parsing routines.
Namely, the higher level routines go out of their way to stop you from
shooting yourself in the foot. For example, parsing into a `Zoned`
requires a time zone annotation.

But parsing into a `Pieces` doesn't require any of that. It just has
to match the Temporal ISO 8601 grammar. Then you can mix and match
the pieces in whatever way you desire. And indeed, you can pretty
easily shoot yourself in the foot with this API. I feel okay about this
because it's tucked into a corner of Jiff that you specifically have to
seek out to use. I've also included examples in the docs of _how_ you
can easily shoot yourself in the foot.

I've included a couple case studies in the docs reflecting some real
world examples I've come across in the issue tracker.

Ref #112, Ref #181, Closes #188,
Ref https://github.com/tc39/proposal-temporal/issues/2930
---
 CHANGELOG.md                |   21 +
 src/fmt/offset.rs           |   19 +
 src/fmt/rfc9557.rs          |   76 +-
 src/fmt/temporal/mod.rs     |  207 +++++
 src/fmt/temporal/parser.rs  |   21 +-
 src/fmt/temporal/pieces.rs  | 1725 +++++++++++++++++++++++++++++++++++
 src/fmt/temporal/printer.rs |   68 ++
 src/lib.rs                  |    7 +-
 src/tz/offset.rs            |   56 ++
 src/util/borrow.rs          |   66 ++
 src/zoned.rs                |    8 +-
 11 files changed, 2227 insertions(+), 47 deletions(-)
 create mode 100644 src/fmt/temporal/pieces.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b72000a..631d3589 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,26 @@
 # CHANGELOG
 
+0.1.20 (2025-01-03)
+===================
+This release inclues a new type, `Pieces`, in the `jiff::fmt::temporal`
+sub-module. This exposes the individual components of a parsed Temporal
+ISO 8601 datetime string. It allows users of Jiff to circumvent the checks
+in the higher level parsing routines that prevent you from shooting yourself
+in the foot.
+
+For example, parsing into a `Zoned` will return an error for raw RFC 3339
+timestamps like `2025-01-03T22:03-05` because there is no time zone annotation.
+Without a time zone, Jiff cannot do time zone aware arithmetic and rounding.
+Instead, such a datetime can only be parsed into a `Timestamp`. This lower
+level `Pieces` API now permits users of Jiff to parse this string into its
+component parts and assemble it into a `Zoned` if they so choose.
+
+Enhancements:
+
+* [#188](https://github.com/BurntSushi/jiff/issues/188):
+Add `fmt::temporal::Pieces` for granular datetime parsing and formatting.
+
+
 0.1.19 (2025-01-02)
 ===================
 This releases includes a UTF-8 related bug fix and a few enhancements.
diff --git a/src/fmt/offset.rs b/src/fmt/offset.rs
index 96da13b0..3b1a13ef 100644
--- a/src/fmt/offset.rs
+++ b/src/fmt/offset.rs
@@ -106,6 +106,7 @@ from [Temporal's hybrid grammar].
 use crate::{
     error::{err, Error, ErrorContext},
     fmt::{
+        temporal::{PiecesNumericOffset, PiecesOffset},
         util::{parse_temporal_fraction, FractionalFormatter},
         Parsed,
     },
@@ -156,6 +157,24 @@ impl ParsedOffset {
         }
     }
 
+    /// Convert a parsed offset to a more structured representation.
+    ///
+    /// This is like `to_offset`, but preserves `Z` and `-00:00` versus
+    /// `+00:00`. This does still attempt to create an `Offset`, and that
+    /// construction can fail.
+    pub(crate) fn to_pieces_offset(&self) -> Result<PiecesOffset, Error> {
+        match self.kind {
+            ParsedOffsetKind::Zulu => Ok(PiecesOffset::Zulu),
+            ParsedOffsetKind::Numeric(ref numeric) => {
+                let mut off = PiecesNumericOffset::from(numeric.to_offset()?);
+                if numeric.sign < 0 {
+                    off = off.with_negative_zero();
+                }
+                Ok(PiecesOffset::from(off))
+            }
+        }
+    }
+
     /// Whether this parsed offset corresponds to Zulu time or not.
     ///
     /// This is useful in error reporting for parsing civil times. Namely, we
diff --git a/src/fmt/rfc9557.rs b/src/fmt/rfc9557.rs
index e50cf209..817992f1 100644
--- a/src/fmt/rfc9557.rs
+++ b/src/fmt/rfc9557.rs
@@ -98,9 +98,9 @@ use crate::{
     error::{err, Error},
     fmt::{
         offset::{self, ParsedOffset},
+        temporal::{TimeZoneAnnotation, TimeZoneAnnotationKind},
         Parsed,
     },
-    tz::{TimeZone, TimeZoneDatabase},
     util::{escape, parse},
 };
 
@@ -130,41 +130,16 @@ impl<'i> ParsedAnnotations<'i> {
         ParsedAnnotations { input: escape::Bytes(&[]), time_zone: None }
     }
 
-    /// If a time zone annotation was parsed, then this returns the annotation
-    /// converted to a `TimeZone`, along with a flag indicating whether it
-    /// is "critical" or not. (When it's "critical," there should be more
-    /// stringent validation.)
+    /// Turns this parsed time zone into a structured time zone annotation,
+    /// if an annotation was found. Otherwise, returns `Ok(None)`.
     ///
-    /// If the time zone annotation parsed successfully but was either not
-    /// found in the database given or otherwise invalid, then an error is
-    /// returned.
-    ///
-    /// `None` is returned only when there was no time zone annotation.
-    pub(crate) fn to_time_zone(
+    /// This can return an error if the parsed offset could not be converted
+    /// to a `crate::tz::Offset`.
+    pub(crate) fn to_time_zone_annotation(
         &self,
-        db: &TimeZoneDatabase,
-    ) -> Result<Option<(TimeZone, bool)>, Error> {
+    ) -> Result<Option<TimeZoneAnnotation<'i>>, Error> {
         let Some(ref parsed) = self.time_zone else { return Ok(None) };
-        // NOTE: We don't currently utilize the critical flag here. Temporal
-        // seems to ignore it. It's not quite clear what else we'd do with it,
-        // particularly given that we provide a way to do conflict resolution
-        // between offsets and time zones.
-        match *parsed {
-            ParsedTimeZone::Named { critical, name } => {
-                let tz = match db.get(name) {
-                    Ok(tz) => tz,
-                    Err(err) => return Err(err!("{}", err)),
-                };
-                Ok(Some((tz, critical)))
-            }
-            ParsedTimeZone::Offset { critical, ref offset } => {
-                let offset = match offset.to_offset() {
-                    Ok(offset) => offset,
-                    Err(err) => return Err(err),
-                };
-                Ok(Some((TimeZone::fixed(offset), critical)))
-            }
-        }
+        Ok(Some(parsed.to_time_zone_annotation()?))
     }
 }
 
@@ -187,6 +162,31 @@ enum ParsedTimeZone<'i> {
     },
 }
 
+impl<'i> ParsedTimeZone<'i> {
+    /// Turns this parsed time zone into a structured time zone annotation.
+    ///
+    /// This can return an error if the parsed offset could not be converted
+    /// to a `crate::tz::Offset`.
+    ///
+    /// This also includes a flag of whether the annotation is "critical" or
+    /// not.
+    pub(crate) fn to_time_zone_annotation(
+        &self,
+    ) -> Result<TimeZoneAnnotation<'i>, Error> {
+        let (kind, critical) = match *self {
+            ParsedTimeZone::Named { name, critical } => {
+                let kind = TimeZoneAnnotationKind::from(name);
+                (kind, critical)
+            }
+            ParsedTimeZone::Offset { ref offset, critical } => {
+                let kind = TimeZoneAnnotationKind::Offset(offset.to_offset()?);
+                (kind, critical)
+            }
+        };
+        Ok(TimeZoneAnnotation { kind, critical })
+    }
+}
+
 /// A parser for RFC 9557 annotations.
 #[derive(Debug)]
 pub(crate) struct Parser {
@@ -603,8 +603,9 @@ mod tests {
                 .parse(input)
                 .unwrap()
                 .value
-                .to_time_zone(crate::tz::db())
+                .to_time_zone_annotation()
                 .unwrap()
+                .map(|ann| (ann.to_time_zone().unwrap(), ann.is_critical()))
         };
 
         insta::assert_debug_snapshot!(p(b"[America/New_York]"), @r###"
@@ -1024,13 +1025,16 @@ mod tests {
 
     #[cfg(feature = "std")]
     #[test]
-    fn err_time_zone() {
+    fn err_time_zone_db_lookup() {
         let p = |input| {
             Parser::new()
                 .parse(input)
                 .unwrap()
                 .value
-                .to_time_zone(crate::tz::db())
+                .to_time_zone_annotation()
+                .unwrap()
+                .unwrap()
+                .to_time_zone()
                 .unwrap_err()
         };
 
diff --git a/src/fmt/temporal/mod.rs b/src/fmt/temporal/mod.rs
index a1bfdd42..446d4c95 100644
--- a/src/fmt/temporal/mod.rs
+++ b/src/fmt/temporal/mod.rs
@@ -175,7 +175,13 @@ use crate::{
     SignedDuration, Timestamp, Zoned,
 };
 
+pub use self::pieces::{
+    Pieces, PiecesNumericOffset, PiecesOffset, TimeZoneAnnotation,
+    TimeZoneAnnotationKind, TimeZoneAnnotationName,
+};
+
 mod parser;
+mod pieces;
 mod printer;
 
 /// The default date time parser that we use throughout Jiff.
@@ -753,6 +759,129 @@ impl DateTimeParser {
         let time = parsed_time.to_time();
         Ok(time)
     }
+
+    /// Parse a Temporal datetime string into [`Pieces`].
+    ///
+    /// This is a lower level routine meant to give callers raw access to the
+    /// individual "pieces" of a parsed Temporal ISO 8601 datetime string.
+    /// Note that this only includes strings that have a date component.
+    ///
+    /// The benefit of this routine is that it only checks that the datetime
+    /// is itself valid. It doesn't do any automatic diambiguation, offset
+    /// conflict resolution or attempt to prevent you from shooting yourself
+    /// in the foot. For example, this routine will let you parse a fixed
+    /// offset datetime into a `Zoned` without a time zone abbreviation.
+    ///
+    /// Note that when using this routine, the
+    /// [`DateTimeParser::offset_conflict`] and
+    /// [`DateTimeParser::disambiguation`] configuration knobs are completely
+    /// ignored. This is because with the lower level `Pieces`, callers must
+    /// handle offset conflict resolution (if they want it) themselves. See
+    /// the [`Pieces`] documentation for a case study on how to do this if
+    /// you need it.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error if the datetime string given is invalid or if it
+    /// is valid but doesn't fit in the date range supported by Jiff.
+    ///
+    /// # Example
+    ///
+    /// This shows how to parse a fixed offset timestamp into a `Zoned`.
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::DateTimeParser, tz::TimeZone};
+    ///
+    /// static PARSER: DateTimeParser = DateTimeParser::new();
+    ///
+    /// let timestamp = "2025-01-02T15:13-05";
+    ///
+    /// // Normally this operation will fail.
+    /// assert_eq!(
+    ///     PARSER.parse_zoned(timestamp).unwrap_err().to_string(),
+    ///     "failed to find time zone in square brackets in \
+    ///      \"2025-01-02T15:13-05\", which is required for \
+    ///      parsing a zoned instant",
+    /// );
+    ///
+    /// // But you can work-around this with `Pieces`, which gives you direct
+    /// // access to the components parsed from the string.
+    /// let pieces = PARSER.parse_pieces(timestamp)?;
+    /// let time = pieces.time().unwrap_or_else(jiff::civil::Time::midnight);
+    /// let dt = pieces.date().to_datetime(time);
+    /// let tz = match pieces.to_time_zone()? {
+    ///     Some(tz) => tz,
+    ///     None => {
+    ///         let Some(offset) = pieces.to_numeric_offset() else {
+    ///             let msg = format!(
+    ///                 "timestamp `{timestamp}` has no time zone \
+    ///                  or offset, and thus cannot be parsed into \
+    ///                  an instant",
+    ///             );
+    ///             return Err(msg.into());
+    ///         };
+    ///         TimeZone::fixed(offset)
+    ///     }
+    /// };
+    /// // We don't bother with offset conflict resolution. And note that
+    /// // this uses automatic "compatible" disambiguation in the case of
+    /// // discontinuities. Of course, this is all moot if `TimeZone` is
+    /// // fixed. The above code handles the case where it isn't!
+    /// let zdt = tz.to_zoned(dt)?;
+    /// assert_eq!(zdt.to_string(), "2025-01-02T15:13:00-05:00[-05:00]");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// # Example: work around errors when a `Z` (Zulu) offset is encountered
+    ///
+    /// Because parsing a date with a `Z` offset and interpreting it as
+    /// a civil date or time is usually a bug, it is forbidden:
+    ///
+    /// ```
+    /// use jiff::{civil::date, fmt::temporal::DateTimeParser};
+    ///
+    /// static PARSER: DateTimeParser = DateTimeParser::new();
+    ///
+    /// assert_eq!(
+    ///     PARSER.parse_date("2024-03-10T00:00:00Z").unwrap_err().to_string(),
+    ///     "cannot parse civil date from string with a Zulu offset, \
+    ///      parse as a `Timestamp` and convert to a civil date instead",
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// But this sort of error checking doesn't happen when you parse into a
+    /// [`Pieces`]. You just get what was parsed, which lets you extract a
+    /// date even if the higher level APIs forbid it:
+    ///
+    /// ```
+    /// use jiff::{civil, fmt::temporal::DateTimeParser, tz::Offset};
+    ///
+    /// static PARSER: DateTimeParser = DateTimeParser::new();
+    ///
+    /// let pieces = PARSER.parse_pieces("2024-03-10T00:00:00Z")?;
+    /// assert_eq!(pieces.date(), civil::date(2024, 3, 10));
+    /// assert_eq!(pieces.time(), Some(civil::time(0, 0, 0, 0)));
+    /// assert_eq!(pieces.to_numeric_offset(), Some(Offset::UTC));
+    /// assert_eq!(pieces.to_time_zone()?, None);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This is usually not the right thing to do. It isn't even suggested in
+    /// the error message above. But if you know it's the right thing, then
+    /// `Pieces` will let you do it.
+    pub fn parse_pieces<'i, I: ?Sized + AsRef<[u8]> + 'i>(
+        &self,
+        input: &'i I,
+    ) -> Result<Pieces<'i>, Error> {
+        let input = input.as_ref();
+        let parsed = self.p.parse_temporal_datetime(input)?.into_full()?;
+        let pieces = parsed.to_pieces()?;
+        Ok(pieces)
+    }
 }
 
 /// A printer for Temporal datetimes.
@@ -1162,6 +1291,50 @@ impl DateTimePrinter {
         buf
     }
 
+    /// Format `Pieces` of a Temporal datetime.
+    ///
+    /// This is a convenience routine for [`DateTimePrinter::print_pieces`]
+    /// with a `String`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{
+    ///     fmt::temporal::{DateTimePrinter, Pieces},
+    ///     tz::offset,
+    ///     Timestamp,
+    /// };
+    ///
+    /// const PRINTER: DateTimePrinter = DateTimePrinter::new();
+    ///
+    /// let pieces = Pieces::from(Timestamp::UNIX_EPOCH);
+    /// assert_eq!(
+    ///     PRINTER.pieces_to_string(&pieces),
+    ///     "1970-01-01T00:00:00Z",
+    /// );
+    ///
+    /// let pieces = Pieces::from((Timestamp::UNIX_EPOCH, offset(0)));
+    /// assert_eq!(
+    ///     PRINTER.pieces_to_string(&pieces),
+    ///     "1970-01-01T00:00:00+00:00",
+    /// );
+    ///
+    /// let pieces = Pieces::from((Timestamp::UNIX_EPOCH, offset(-5)));
+    /// assert_eq!(
+    ///     PRINTER.pieces_to_string(&pieces),
+    ///     "1969-12-31T19:00:00-05:00",
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[cfg(feature = "alloc")]
+    pub fn pieces_to_string(&self, pieces: &Pieces) -> alloc::string::String {
+        let mut buf = alloc::string::String::with_capacity(4);
+        // OK because writing to `String` never fails.
+        self.print_pieces(pieces, &mut buf).unwrap();
+        buf
+    }
+
     /// Print a `Zoned` datetime to the given writer.
     ///
     /// # Errors
@@ -1412,6 +1585,40 @@ impl DateTimePrinter {
     ) -> Result<(), Error> {
         self.p.print_time(time, wtr)
     }
+
+    /// Print the `Pieces` of a Temporal datetime.
+    ///
+    /// # Errors
+    ///
+    /// This only returns an error when writing to the given [`Write`]
+    /// implementation would fail. Some such implementations, like for `String`
+    /// and `Vec<u8>`, never fail (unless memory allocation fails). In such
+    /// cases, it would be appropriate to call `unwrap()` on the result.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{civil::date, fmt::temporal::{DateTimePrinter, Pieces}};
+    ///
+    /// const PRINTER: DateTimePrinter = DateTimePrinter::new();
+    ///
+    /// let pieces = Pieces::from(date(2024, 6, 15))
+    ///     .with_time_zone_name("US/Eastern");
+    ///
+    /// let mut buf = String::new();
+    /// // Printing to a `String` can never fail.
+    /// PRINTER.print_pieces(&pieces, &mut buf).unwrap();
+    /// assert_eq!(buf, "2024-06-15[US/Eastern]");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    pub fn print_pieces<W: Write>(
+        &self,
+        pieces: &Pieces,
+        wtr: W,
+    ) -> Result<(), Error> {
+        self.p.print_pieces(pieces, wtr)
+    }
 }
 
 /// A parser for Temporal durations.
diff --git a/src/fmt/temporal/parser.rs b/src/fmt/temporal/parser.rs
index c0c521cb..e10cffa5 100644
--- a/src/fmt/temporal/parser.rs
+++ b/src/fmt/temporal/parser.rs
@@ -4,6 +4,7 @@ use crate::{
     fmt::{
         offset::{self, ParsedOffset},
         rfc9557::{self, ParsedAnnotations},
+        temporal::Pieces,
         util::{
             fractional_time_to_duration, fractional_time_to_span,
             parse_temporal_fraction,
@@ -35,6 +36,21 @@ pub(super) struct ParsedDateTime<'i> {
 }
 
 impl<'i> ParsedDateTime<'i> {
+    #[inline(always)]
+    pub(super) fn to_pieces(&self) -> Result<Pieces<'i>, Error> {
+        let mut pieces = Pieces::from(self.date.date);
+        if let Some(ref time) = self.time {
+            pieces = pieces.with_time(time.time);
+        }
+        if let Some(ref offset) = self.offset {
+            pieces = pieces.with_offset(offset.to_pieces_offset()?);
+        }
+        if let Some(ann) = self.annotations.to_time_zone_annotation()? {
+            pieces = pieces.with_time_zone_annotation(ann);
+        }
+        Ok(pieces)
+    }
+
     #[inline(always)]
     pub(super) fn to_zoned(
         &self,
@@ -56,14 +72,15 @@ impl<'i> ParsedDateTime<'i> {
         let dt = DateTime::from_parts(self.date.date, time);
 
         // We always require a time zone when parsing a zoned instant.
-        let (tz, _critical) =
-            self.annotations.to_time_zone(db)?.ok_or_else(|| {
+        let tz_annotation =
+            self.annotations.to_time_zone_annotation()?.ok_or_else(|| {
                 err!(
                     "failed to find time zone in square brackets \
                      in {:?}, which is required for parsing a zoned instant",
                     self.input,
                 )
             })?;
+        let tz = tz_annotation.to_time_zone_with(db)?;
 
         // If there's no offset, then our only choice, regardless of conflict
         // resolution preference, is to use the time zone. That is, there is no
diff --git a/src/fmt/temporal/pieces.rs b/src/fmt/temporal/pieces.rs
new file mode 100644
index 00000000..7fcf6682
--- /dev/null
+++ b/src/fmt/temporal/pieces.rs
@@ -0,0 +1,1725 @@
+use crate::{
+    civil::{Date, DateTime, Time},
+    error::Error,
+    tz::{Offset, TimeZone, TimeZoneDatabase},
+    util::borrow::StringCow,
+    Timestamp, Zoned,
+};
+
+/// A low level representation of a parsed Temporal ISO 8601 datetime string.
+///
+/// Most users should not need to use or care about this type. Its purpose is
+/// to represent the individual components of a datetime string for more
+/// flexible parsing when use cases call for it.
+///
+/// One can parse into `Pieces` via [`Pieces::parse`]. Its date, time
+/// (optional), offset (optional) and time zone annotation (optional) can be
+/// queried independently. Each component corresponds to the following in a
+/// datetime string:
+///
+/// ```text
+/// {date}T{time}{offset}[{time-zone-annotation}]
+/// ```
+///
+/// For example:
+///
+/// ```text
+/// 2025-01-03T19:54-05[America/New_York]
+/// ```
+///
+/// A date is the only required component.
+///
+/// A `Pieces` can also be constructed from structured values via its `From`
+/// trait implementations. The `From` trait has the following implementations
+/// available:
+///
+/// * `From<Date>` creates a `Pieces` with just a civil [`Date`]. All other
+/// components are left empty.
+/// * `From<DateTime>` creates a `Pieces` with a civil [`Date`] and [`Time`].
+/// The offset and time zone annotation are left empty.
+/// * `From<Timestamp>` creates a `Pieces` from a [`Timestamp`] using
+/// a Zulu offset. This signifies that the precise instant is known, but the
+/// local time's offset from UTC is unknown. The [`Date`] and [`Time`] are
+/// determined via `Offset::UTC.to_datetime(timestamp)`. The time zone
+/// annotation is left empty.
+/// * `From<(Timestamp, Offset)>` creates a `Pieces` from a [`Timestamp`] and
+/// an [`Offset`]. The [`Date`] and [`Time`] are determined via
+/// `offset.to_datetime(timestamp)`. The time zone annotation is left empty.
+/// * `From<&Zoned>` creates a `Pieces` from a [`Zoned`]. This populates all
+/// fields of a `Pieces`.
+///
+/// A `Pieces` can be converted to a Temporal ISO 8601 string via its `Display`
+/// trait implementation.
+///
+/// # Example: distinguishing between `Z`, `+00:00` and `-00:00`
+///
+/// With `Pieces`, it's possible to parse a datetime string and inspect the
+/// "type" of its offset when it is zero. This makes use of the
+/// [`PiecesOffset`] and [`PiecesNumericOffset`] auxiliary types.
+///
+/// ```
+/// use jiff::{
+///     fmt::temporal::{Pieces, PiecesNumericOffset, PiecesOffset},
+///     tz::Offset,
+/// };
+///
+/// let pieces = Pieces::parse("1970-01-01T00:00:00Z")?;
+/// let off = pieces.offset().unwrap();
+/// // Parsed as Zulu.
+/// assert_eq!(off, PiecesOffset::Zulu);
+/// // Gets converted from Zulu to UTC, i.e., just zero.
+/// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+///
+/// let pieces = Pieces::parse("1970-01-01T00:00:00-00:00")?;
+/// let off = pieces.offset().unwrap();
+/// // Parsed as a negative zero.
+/// assert_eq!(off, PiecesOffset::from(
+///     PiecesNumericOffset::from(Offset::UTC).with_negative_zero(),
+/// ));
+/// // Gets converted from -00:00 to UTC, i.e., just zero.
+/// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+///
+/// let pieces = Pieces::parse("1970-01-01T00:00:00+00:00")?;
+/// let off = pieces.offset().unwrap();
+/// // Parsed as a positive zero.
+/// assert_eq!(off, PiecesOffset::from(
+///     PiecesNumericOffset::from(Offset::UTC),
+/// ));
+/// // Gets converted from -00:00 to UTC, i.e., just zero.
+/// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// It's rare to need to care about these differences, but the above example
+/// demonstrates that `Pieces` doesn't try to do any automatic translation for
+/// you.
+///
+/// # Example: it is very easy to misuse `Pieces`
+///
+/// This example shows how easily you can shoot yourself in the foot with
+/// `Pieces`:
+///
+/// ```
+/// use jiff::{fmt::temporal::{Pieces, TimeZoneAnnotation}, tz};
+///
+/// let mut pieces = Pieces::parse("2025-01-03T07:55+02[Africa/Cairo]")?;
+/// pieces = pieces.with_offset(tz::offset(-10));
+/// // This is nonsense because the offset isn't compatible with the time zone!
+/// // Moreover, the actual instant that this timestamp represents has changed.
+/// assert_eq!(pieces.to_string(), "2025-01-03T07:55:00-10:00[Africa/Cairo]");
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// In the above example, we take a parsed `Pieces`, change its offset and
+/// then format it back into a string. There are no speed bumps or errors.
+/// A `Pieces` will just blindly follow your instruction, even if it produces
+/// a nonsense result. Nonsense results are still parsable back into `Pieces`:
+///
+/// ```
+/// use jiff::{civil, fmt::temporal::Pieces, tz::{TimeZone, offset}};
+///
+/// let pieces = Pieces::parse("2025-01-03T07:55:00-10:00[Africa/Cairo]")?;
+/// assert_eq!(pieces.date(), civil::date(2025, 1, 3));
+/// assert_eq!(pieces.time(), Some(civil::time(7, 55, 0, 0)));
+/// assert_eq!(pieces.to_numeric_offset(), Some(offset(-10)));
+/// assert_eq!(pieces.to_time_zone()?, Some(TimeZone::get("Africa/Cairo")?));
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// This exemplifies that `Pieces` is a mostly "dumb" type that passes
+/// through the data it contains, even if it doesn't make sense.
+///
+/// # Case study: how to parse `2025-01-03T17:28-05` into `Zoned`
+///
+/// One thing in particular that `Pieces` enables callers to do is side-step
+/// some of the stricter requirements placed on the higher level parsing
+/// functions (such as `Zoned`'s `FromStr` trait implementation). For example,
+/// parsing a datetime string into a `Zoned` _requires_ that the string contain
+/// a time zone annotation. Namely, parsing `2025-01-03T17:28-05` into a
+/// `Zoned` will fail:
+///
+/// ```
+/// use jiff::Zoned;
+///
+/// assert_eq!(
+///     "2025-01-03T17:28-05".parse::<Zoned>().unwrap_err().to_string(),
+///     "failed to find time zone in square brackets in \
+///      \"2025-01-03T17:28-05\", which is required for \
+///      parsing a zoned instant",
+/// );
+/// ```
+///
+/// The above fails because an RFC 3339 timestamp only contains an offset,
+/// not a time zone, and thus the resulting `Zoned` could never do time zone
+/// aware arithmetic.
+///
+/// However, in some cases, you might want to bypass these protections and
+/// creat a `Zoned` value with a fixed offset time zone anyway. For example,
+/// perhaps your use cases don't need time zone aware arithmetic, but want to
+/// preserve the offset anyway. This can be accomplished with `Pieces`:
+///
+/// ```
+/// use jiff::{fmt::temporal::Pieces, tz::TimeZone};
+///
+/// let pieces = Pieces::parse("2025-01-03T17:28-05")?;
+/// let time = pieces.time().unwrap_or_else(jiff::civil::Time::midnight);
+/// let dt = pieces.date().to_datetime(time);
+/// let Some(offset) = pieces.to_numeric_offset() else {
+///     let msg = format!(
+///         "datetime string has no offset, \
+///          and thus cannot be parsed into an instant",
+///     );
+///     return Err(msg.into());
+/// };
+/// let zdt = TimeZone::fixed(offset).to_zoned(dt)?;
+/// assert_eq!(zdt.to_string(), "2025-01-03T17:28:00-05:00[-05:00]");
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// One problem with the above code snippet is that it completely ignores if
+/// a time zone annotation is present. If it is, it probably makes sense to use
+/// it, but "fall back" to a fixed offset time zone if it isn't (which the
+/// higher level `Zoned` parsing function won't do for you):
+///
+/// ```
+/// use jiff::{fmt::temporal::Pieces, tz::TimeZone};
+///
+/// let timestamp = "2025-01-02T15:13-05";
+///
+/// let pieces = Pieces::parse(timestamp)?;
+/// let time = pieces.time().unwrap_or_else(jiff::civil::Time::midnight);
+/// let dt = pieces.date().to_datetime(time);
+/// let tz = match pieces.to_time_zone()? {
+///     Some(tz) => tz,
+///     None => {
+///         let Some(offset) = pieces.to_numeric_offset() else {
+///             let msg = format!(
+///                 "timestamp `{timestamp}` has no time zone \
+///                  or offset, and thus cannot be parsed into \
+///                  an instant",
+///             );
+///             return Err(msg.into());
+///         };
+///         TimeZone::fixed(offset)
+///     }
+/// };
+/// // We don't bother with offset conflict resolution. And note that
+/// // this uses automatic "compatible" disambiguation in the case of
+/// // discontinuities. Of course, this is all moot if `TimeZone` is
+/// // fixed. The above code handles the case where it isn't!
+/// let zdt = tz.to_zoned(dt)?;
+/// assert_eq!(zdt.to_string(), "2025-01-02T15:13:00-05:00[-05:00]");
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// This is mostly the same as above, but if an annotation is present, we use
+/// a `TimeZone` derived from that over the offset present.
+///
+/// However, this still doesn't quite capture what happens when parsing into a
+/// `Zoned` value. In particular, parsing into a `Zoned` is _also_ doing offset
+/// conflict resolution for you. An offset conflict occurs when there is a
+/// mismatch between the offset in an RFC 3339 timestamp and the time zone in
+/// an RFC 9557 time zone annotation.
+///
+/// For example, `2024-06-14T17:30-05[America/New_York]` has a mismatch
+/// since the date is in daylight saving time, but the offset, `-05`, is the
+/// offset for standard time in `America/New_York`. If this datetime were
+/// fed to the above code, then the `-05` offset would be completely ignored
+/// and `America/New_York` would resolve the datetime based on its rules. In
+/// this case, you'd get `2024-06-14T17:30-04`, which is a different instant
+/// than the original datetime!
+///
+/// You can either implement your own conflict resolution or use
+/// [`tz::OffsetConflict`](crate::tz::OffsetConflict) to do it for you.
+///
+/// ```
+/// use jiff::{fmt::temporal::Pieces, tz::{OffsetConflict, TimeZone}};
+///
+/// let timestamp = "2024-06-14T17:30-05[America/New_York]";
+/// // The default for conflict resolution when parsing into a `Zoned` is
+/// // actually `Reject`, but we use `AlwaysOffset` here to show a different
+/// // strategy. You'll want to pick the conflict resolution that suits your
+/// // needs. The `Reject` strategy is what you should pick if you aren't
+/// // sure.
+/// let conflict_resolution = OffsetConflict::AlwaysOffset;
+///
+/// let pieces = Pieces::parse(timestamp)?;
+/// let time = pieces.time().unwrap_or_else(jiff::civil::Time::midnight);
+/// let dt = pieces.date().to_datetime(time);
+/// let ambiguous_zdt = match pieces.to_time_zone()? {
+///     Some(tz) => {
+///         match pieces.to_numeric_offset() {
+///             None => tz.into_ambiguous_zoned(dt),
+///             Some(offset) => {
+///                 conflict_resolution.resolve(dt, offset, tz)?
+///             }
+///         }
+///     }
+///     None => {
+///         let Some(offset) = pieces.to_numeric_offset() else {
+///             let msg = format!(
+///                 "timestamp `{timestamp}` has no time zone \
+///                  or offset, and thus cannot be parsed into \
+///                  an instant",
+///             );
+///             return Err(msg.into());
+///         };
+///         // Won't even be ambiguous, but gets us the same
+///         // type as the branch above.
+///         TimeZone::fixed(offset).into_ambiguous_zoned(dt)
+///     }
+/// };
+/// // We do compatible disambiguation here like we do in the previous
+/// // examples, but you could choose any strategy. As with offset conflict
+/// // resolution, if you aren't sure what to pick, a safe choice here would
+/// // be `ambiguous_zdt.unambiguous()`, which will return an error if the
+/// // datetime is ambiguous in any way. Then, if you ever hit an error, you
+/// // can examine the case to see if it should be handled in a different way.
+/// let zdt = ambiguous_zdt.compatible()?;
+/// // Notice that we now have a different civil time and offset, but the
+/// // instant it corresponds to is the same as the one we started with.
+/// assert_eq!(zdt.to_string(), "2024-06-14T18:30:00-04:00[America/New_York]");
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// The above has effectively completely rebuilt the higher level `Zoned`
+/// parsing routine, but with a fallback to a fixed time zone when a time zone
+/// annotation is not present.
+///
+/// # Case study: inferring the time zone of RFC 3339 timestamps
+///
+/// As [one real world use case details][infer-time-zone], it might be
+/// desirable to try and infer the time zone of RFC 3339 timestamps with
+/// varying offsets. This might be applicable when:
+///
+/// * You have out-of-band information, possibly contextual, that indicates
+/// the timestamps have to come from a fixed set of time zones.
+/// * The time zones have different standard offsets.
+/// * You have a specific desire or need to use a [`Zoned`] value for its
+/// ergonomics and time zone aware handling. After all, in this case, you
+/// believe the timestamps to actually be generated from a specific time zone,
+/// but the interchange format doesn't support carrying that information. Or
+/// the source data simply omits it.
+///
+/// In other words, you might be trying to make the best of a bad situation.
+///
+/// A `Pieces` can help you accomplish this because it gives you access to each
+/// component of a parsed datetime, and thus lets you implement arbitrary logic
+/// for how to translate that into a `Zoned`. In this case, there is
+/// contextual information that Jiff can't possibly know about.
+///
+/// The general approach we take here is to make use of
+/// [`tz::OffsetConflict`](crate::tz::OffsetConflict) to query whether a
+/// timestamp has a fixed offset compatible with a particular time zone. And if
+/// so, we can _probably_ assume it comes from that time zone. One hitch is
+/// that it's possible for the timestamp to be valid for multiple time zones,
+/// so we check that as well.
+///
+/// In the use case linked above, we have fixed offset timestamps from
+/// `America/Chicago` and `America/New_York`. So let's try implementing the
+/// above strategy. Note that we assume our inputs are RFC 3339 fixed offset
+/// timestamps and error otherwise. This is just to keep things simple. To
+/// handle data that is more varied, see the previous case study where we
+/// respect a time zone annotation if it's present, and fall back to a fixed
+/// offset time zone if it isn't.
+///
+/// ```
+/// use jiff::{fmt::temporal::Pieces, tz::{OffsetConflict, TimeZone}, Zoned};
+///
+/// // The time zones we're allowed to choose from.
+/// let tzs = &[
+///     TimeZone::get("America/New_York")?,
+///     TimeZone::get("America/Chicago")?,
+/// ];
+///
+/// // Here's our data that lacks time zones. The task is to assign a time zone
+/// // from `tzs` to each below and convert it to a `Zoned`. If we fail on any
+/// // one, then we substitute `None`.
+/// let data = &[
+///     "2024-01-13T10:33-05",
+///     "2024-01-25T12:15-06",
+///     "2024-03-10T02:30-05",
+///     "2024-06-08T14:01-05",
+///     "2024-06-12T11:46-04",
+///     "2024-11-03T01:30-05",
+/// ];
+/// // Our answers.
+/// let mut zdts: Vec<Option<Zoned>> = vec![];
+/// for string in data {
+///     // Parse and gather up the data that we can from the input.
+///     // In this case, that's a civil datetime and an offset from UTC.
+///     let pieces = Pieces::parse(string)?;
+///     let time = pieces.time().unwrap_or_else(jiff::civil::Time::midnight);
+///     let dt = pieces.date().to_datetime(time);
+///     let Some(offset) = pieces.to_numeric_offset() else {
+///         // A robust implementation should use a TZ annotation if present.
+///         return Err("missing offset".into());
+///     };
+///     // Now collect all time zones that are valid for this timestamp.
+///     let mut candidates = vec![];
+///     for tz in tzs {
+///         let result = OffsetConflict::Reject.resolve(dt, offset, tz.clone());
+///         // The parsed offset isn't valid for this time zone, so reject it.
+///         let Ok(ambiguous_zdt) = result else { continue };
+///         // This can never fail because we used the "reject" conflict
+///         // resolution strategy. It will never return an ambiguous
+///         // `Zoned` since we always have a valid offset that does
+///         // disambiguation for us.
+///         let zdt = ambiguous_zdt.unambiguous().unwrap();
+///         candidates.push(zdt);
+///     }
+///     if candidates.len() == 1 {
+///         zdts.push(Some(candidates.pop().unwrap()));
+///     } else {
+///         zdts.push(None);
+///     }
+/// }
+/// assert_eq!(zdts, vec![
+///     Some("2024-01-13T10:33-05[America/New_York]".parse()?),
+///     Some("2024-01-25T12:15-06[America/Chicago]".parse()?),
+///     // Failed because the clock time falls in a gap in the
+///     // transition to daylight saving time, and it could be
+///     // valid for either America/New_York or America/Chicago.
+///     None,
+///     Some("2024-06-08T14:01-05[America/Chicago]".parse()?),
+///     Some("2024-06-12T11:46-04[America/New_York]".parse()?),
+///     // Failed because the clock time falls in a fold in the
+///     // transition out of daylight saving time, and it could be
+///     // valid for either America/New_York or America/Chicago.
+///     None,
+/// ]);
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// The one hitch here is that if the time zones are close to each
+/// geographically and both have daylight saving time, then there are some
+/// RFC 3339 timestamps that are truly ambiguous. For example,
+/// `2024-11-03T01:30-05` is perfectly valid for both `America/New_York` and
+/// `America/Chicago`. In this case, there is no way to tell which time zone
+/// the timestamp belongs to. It might be reasonable to return an error in
+/// this case or omit the timestamp. It depends on what you need to do.
+///
+/// With more effort, it would also be possible to optimize the above routine
+/// by utilizing [`TimeZone::preceding`] and [`TimeZone::following`] to get
+/// the exact boundaries of each time zone transition. Then you could use an
+/// offset lookup table for each range to determine the appropriate time zone.
+///
+/// [infer-time-zone]: https://github.com/BurntSushi/jiff/discussions/181#discussioncomment-11729435
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Pieces<'n> {
+    date: Date,
+    time: Option<Time>,
+    offset: Option<PiecesOffset>,
+    time_zone_annotation: Option<TimeZoneAnnotation<'n>>,
+}
+
+impl<'n> Pieces<'n> {
+    /// Parses a Temporal ISO 8601 datetime string into a `Pieces`.
+    ///
+    /// This is a convenience routine for
+    /// [`DateTimeParser::parses_pieces`](crate::fmt::temporal::DateTimeParser::parse_pieces).
+    ///
+    /// Note that the `Pieces` returned is parameterized by the lifetime of
+    /// `input`. This is because it might borrow a sub-slice of `input` for
+    /// a time zone annotation name. For example,
+    /// `Canada/Yukon` in `2025-01-03T16:42-07[Canada/Yukon]`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{civil, fmt::temporal::Pieces, tz::TimeZone};
+    ///
+    /// let pieces = Pieces::parse("2025-01-03T16:42[Canada/Yukon]")?;
+    /// assert_eq!(pieces.date(), civil::date(2025, 1, 3));
+    /// assert_eq!(pieces.time(), Some(civil::time(16, 42, 0, 0)));
+    /// assert_eq!(pieces.to_numeric_offset(), None);
+    /// assert_eq!(pieces.to_time_zone()?, Some(TimeZone::get("Canada/Yukon")?));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn parse<I: ?Sized + AsRef<[u8]> + 'n>(
+        input: &'n I,
+    ) -> Result<Pieces<'n>, Error> {
+        let input = input.as_ref();
+        super::DEFAULT_DATETIME_PARSER.parse_pieces(input)
+    }
+
+    /// Returns the civil date in this `Pieces`.
+    ///
+    /// Note that every `Pieces` value is guaranteed to have a `Date`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{civil, fmt::temporal::Pieces};
+    ///
+    /// let pieces = Pieces::parse("2025-01-03")?;
+    /// assert_eq!(pieces.date(), civil::date(2025, 1, 3));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn date(&self) -> Date {
+        self.date
+    }
+
+    /// Returns the civil time in this `Pieces`.
+    ///
+    /// The time component is optional. In
+    /// [`DateTimeParser`](crate::fmt::temporal::DateTimeParser), parsing
+    /// into types that require a time (like [`DateTime`]) when a time is
+    /// missing automatically set the time to midnight. (Or, more precisely,
+    /// the first instant of the day.)
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{civil, fmt::temporal::Pieces, Zoned};
+    ///
+    /// let pieces = Pieces::parse("2025-01-03T14:49:01")?;
+    /// assert_eq!(pieces.date(), civil::date(2025, 1, 3));
+    /// assert_eq!(pieces.time(), Some(civil::time(14, 49, 1, 0)));
+    ///
+    /// // tricksy tricksy, the first instant of 2015-10-18 in Sao Paulo is
+    /// // not midnight!
+    /// let pieces = Pieces::parse("2015-10-18[America/Sao_Paulo]")?;
+    /// // Parsing into pieces just gives us the component parts, so no time:
+    /// assert_eq!(pieces.time(), None);
+    ///
+    /// // But if this uses higher level routines to parse into a `Zoned`,
+    /// // then we can see that the missing time implies the first instant
+    /// // of the day:
+    /// let zdt: Zoned = "2015-10-18[America/Sao_Paulo]".parse()?;
+    /// assert_eq!(zdt.time(), jiff::civil::time(1, 0, 0, 0));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn time(&self) -> Option<Time> {
+        self.time
+    }
+
+    /// Returns the offset in this `Pieces`.
+    ///
+    /// The offset returned can be infallibly converted to a numeric offset,
+    /// i.e., [`Offset`]. But it also includes extra data to indicate whether
+    /// a `Z` or a `-00:00` was parsed. (Neither of which are representable by
+    /// an `Offset`, which doesn't distinguish between Zulu and UTC and doesn't
+    /// represent negative and positive zero differently.)
+    ///
+    /// # Example
+    ///
+    /// This example shows how different flavors of `Offset::UTC` can be parsed
+    /// and inspected.
+    ///
+    /// ```
+    /// use jiff::{
+    ///     fmt::temporal::{Pieces, PiecesNumericOffset, PiecesOffset},
+    ///     tz::Offset,
+    /// };
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00Z")?;
+    /// let off = pieces.offset().unwrap();
+    /// // Parsed as Zulu.
+    /// assert_eq!(off, PiecesOffset::Zulu);
+    /// // Gets converted from Zulu to UTC, i.e., just zero.
+    /// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00-00:00")?;
+    /// let off = pieces.offset().unwrap();
+    /// // Parsed as a negative zero.
+    /// assert_eq!(off, PiecesOffset::from(
+    ///     PiecesNumericOffset::from(Offset::UTC).with_negative_zero(),
+    /// ));
+    /// // Gets converted from -00:00 to UTC, i.e., just zero.
+    /// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00+00:00")?;
+    /// let off = pieces.offset().unwrap();
+    /// // Parsed as a positive zero.
+    /// assert_eq!(off, PiecesOffset::from(
+    ///     PiecesNumericOffset::from(Offset::UTC),
+    /// ));
+    /// // Gets converted from -00:00 to UTC, i.e., just zero.
+    /// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn offset(&self) -> Option<PiecesOffset> {
+        self.offset
+    }
+
+    /// Returns the time zone annotation in this `Pieces`.
+    ///
+    /// A time zone annotation is optional. The higher level
+    /// [`DateTimeParser`](crate::fmt::temporal::DateTimeParser)
+    /// requires a time zone annotation when parsing into a [`Zoned`].
+    ///
+    /// A time zone annotation is either an offset, or more commonly, an IANA
+    /// time zone identifier.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::{Pieces, TimeZoneAnnotation}, tz::offset};
+    ///
+    /// // A time zone annotation from a name:
+    /// let pieces = Pieces::parse("2025-01-02T16:47-05[America/New_York]")?;
+    /// assert_eq!(
+    ///     pieces.time_zone_annotation().unwrap(),
+    ///     &TimeZoneAnnotation::from("America/New_York"),
+    /// );
+    ///
+    /// // A time zone annotation from an offset:
+    /// let pieces = Pieces::parse("2025-01-02T16:47-05[-05:00]")?;
+    /// assert_eq!(
+    ///     pieces.time_zone_annotation().unwrap(),
+    ///     &TimeZoneAnnotation::from(offset(-5)),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn time_zone_annotation(&self) -> Option<&TimeZoneAnnotation<'n>> {
+        self.time_zone_annotation.as_ref()
+    }
+
+    /// A convenience routine for converting an offset on this `Pieces`,
+    /// if present, to a numeric [`Offset`].
+    ///
+    /// This collapses the offsets `Z`, `-00:00` and `+00:00` all to
+    /// [`Offset::UTC`]. If you need to distinguish between them, then use
+    /// [`Pieces::offset`].
+    ///
+    /// # Example
+    ///
+    /// This example shows how `Z`, `-00:00` and `+00:00` all map to the same
+    /// [`Offset`] value:
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::Pieces, tz::Offset};
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00Z")?;
+    /// assert_eq!(pieces.to_numeric_offset(), Some(Offset::UTC));
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00-00:00")?;
+    /// assert_eq!(pieces.to_numeric_offset(), Some(Offset::UTC));
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00+00:00")?;
+    /// assert_eq!(pieces.to_numeric_offset(), Some(Offset::UTC));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_numeric_offset(&self) -> Option<Offset> {
+        self.offset().map(|poffset| poffset.to_numeric_offset())
+    }
+
+    /// A convenience routine for converting a time zone annotation, if
+    /// present, into a [`TimeZone`].
+    ///
+    /// If no annotation is on this `Pieces`, then this returns `Ok(None)`.
+    ///
+    /// This may return an error if the time zone annotation is a name and it
+    /// couldn't be found in Jiff's global time zone database.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::Pieces, tz::{TimeZone, offset}};
+    ///
+    /// // No time zone annotations means you get `Ok(None)`:
+    /// let pieces = Pieces::parse("2025-01-03T17:13-05")?;
+    /// assert_eq!(pieces.to_time_zone()?, None);
+    ///
+    /// // An offset time zone annotation gets you a fixed offset `TimeZone`:
+    /// let pieces = Pieces::parse("2025-01-03T17:13-05[-05]")?;
+    /// assert_eq!(pieces.to_time_zone()?, Some(TimeZone::fixed(offset(-5))));
+    ///
+    /// // A time zone annotation name gets you a IANA time zone:
+    /// let pieces = Pieces::parse("2025-01-03T17:13-05[America/New_York]")?;
+    /// assert_eq!(pieces.to_time_zone()?, Some(TimeZone::get("America/New_York")?));
+    ///
+    /// // A time zone annotation name that doesn't exist gives you an error:
+    /// let pieces = Pieces::parse("2025-01-03T17:13-05[Australia/Bluey]")?;
+    /// assert_eq!(
+    ///     pieces.to_time_zone().unwrap_err().to_string(),
+    ///     "failed to find time zone `Australia/Bluey` in time zone database",
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_time_zone(&self) -> Result<Option<TimeZone>, Error> {
+        self.to_time_zone_with(crate::tz::db())
+    }
+
+    /// A convenience routine for converting a time zone annotation, if
+    /// present, into a [`TimeZone`] using the given [`TimeZoneDatabase`].
+    ///
+    /// If no annotation is on this `Pieces`, then this returns `Ok(None)`.
+    ///
+    /// This may return an error if the time zone annotation is a name and it
+    /// couldn't be found in Jiff's global time zone database.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::Pieces, tz::TimeZone};
+    ///
+    /// // A time zone annotation name gets you a IANA time zone:
+    /// let pieces = Pieces::parse("2025-01-03T17:13-05[America/New_York]")?;
+    /// assert_eq!(
+    ///     pieces.to_time_zone_with(jiff::tz::db())?,
+    ///     Some(TimeZone::get("America/New_York")?),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_time_zone_with(
+        &self,
+        db: &TimeZoneDatabase,
+    ) -> Result<Option<TimeZone>, Error> {
+        let Some(ann) = self.time_zone_annotation() else { return Ok(None) };
+        ann.to_time_zone_with(db).map(Some)
+    }
+
+    /// Set the date on this `Pieces` to the one given.
+    ///
+    /// A `Date` is the minimal piece of information necessary to create a
+    /// `Pieces`. This method will override any previous setting.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{civil, fmt::temporal::Pieces, Timestamp};
+    ///
+    /// let pieces = Pieces::from(civil::date(2025, 1, 3));
+    /// assert_eq!(pieces.to_string(), "2025-01-03");
+    ///
+    /// // Alternatively, build a `Pieces` from another data type, and the
+    /// // date field will be automatically populated.
+    /// let pieces = Pieces::from(Timestamp::from_second(1735930208)?);
+    /// assert_eq!(pieces.date(), civil::date(2025, 1, 3));
+    /// assert_eq!(pieces.to_string(), "2025-01-03T18:50:08Z");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn with_date(self, date: Date) -> Pieces<'n> {
+        Pieces { date, ..self }
+    }
+
+    /// Set the time on this `Pieces` to the one given.
+    ///
+    /// Setting a [`Time`] on `Pieces` is optional. When formatting a
+    /// `Pieces` to a string, a missing `Time` may be omitted from the datetime
+    /// string in some cases. See [`Pieces::with_offset`] for more details.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{civil, fmt::temporal::Pieces};
+    ///
+    /// let pieces = Pieces::from(civil::date(2025, 1, 3))
+    ///     .with_time(civil::time(13, 48, 0, 0));
+    /// assert_eq!(pieces.to_string(), "2025-01-03T13:48:00");
+    /// // Alternatively, build a `Pieces` from a `DateTime` directly:
+    /// let pieces = Pieces::from(civil::date(2025, 1, 3).at(13, 48, 0, 0));
+    /// assert_eq!(pieces.to_string(), "2025-01-03T13:48:00");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn with_time(self, time: Time) -> Pieces<'n> {
+        Pieces { time: Some(time), ..self }
+    }
+
+    /// Set the offset on this `Pieces` to the one given.
+    ///
+    /// Setting the offset on `Pieces` is optional.
+    ///
+    /// The type of offset is polymorphic, and includes anything that can be
+    /// infallibly converted into a [`PiecesOffset`]. This includes an
+    /// [`Offset`].
+    ///
+    /// This refers to the offset in the [RFC 3339] component of a Temporal
+    /// ISO 8601 datetime string.
+    ///
+    /// Since a string like `2025-01-03+11` is not valid, if a `Pieces` has
+    /// an offset set but no [`Time`] set, then formatting the `Pieces` will
+    /// write an explicit `Time` set to midnight.
+    ///
+    /// Note that this is distinct from [`Pieces::with_time_zone_offset`].
+    /// This routine sets the offset on the datetime, while
+    /// `Pieces::with_time_zone_offset` sets the offset inside the time zone
+    /// annotation. When the timestamp offset and the time zone annotation
+    /// offset are both present, then they must be equivalent or else the
+    /// datetime string is not a valid Temporal ISO 8601 string. However, a
+    /// `Pieces` will let you format a string with mismatching offsets.
+    ///
+    /// # Example
+    ///
+    /// This example shows how easily you can shoot yourself in the foot with
+    /// this routine:
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::{Pieces, TimeZoneAnnotation}, tz};
+    ///
+    /// let mut pieces = Pieces::parse("2025-01-03T07:55+02[+02]")?;
+    /// pieces = pieces.with_offset(tz::offset(-10));
+    /// // This is nonsense because the offsets don't match!
+    /// // And notice also that the instant that this timestamp refers to has
+    /// // changed.
+    /// assert_eq!(pieces.to_string(), "2025-01-03T07:55:00-10:00[+02:00]");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This exemplifies that `Pieces` is a mostly "dumb" type that passes
+    /// through the data it contains, even if it doesn't make sense.
+    ///
+    /// # Example: changing the offset can change the instant
+    ///
+    /// Consider this case where a `Pieces` is created directly from a
+    /// `Timestamp`, and then the offset is changed.
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::Pieces, tz, Timestamp};
+    ///
+    /// let pieces = Pieces::from(Timestamp::UNIX_EPOCH)
+    ///     .with_offset(tz::offset(-5));
+    /// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00-05:00");
+    /// ```
+    ///
+    /// You might do this naively as a way of printing the timestamp of the
+    /// Unix epoch with an offset of `-05` from UTC. But the above does not
+    /// correspond to the Unix epoch:
+    ///
+    /// ```
+    /// use jiff::{Timestamp, ToSpan, Unit};
+    ///
+    /// let ts: Timestamp = "1970-01-01T00:00:00-05:00".parse()?;
+    /// assert_eq!(ts.since((Unit::Hour, Timestamp::UNIX_EPOCH))?, 5.hours());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This further exemplifies how `Pieces` is just a "dumb" type that
+    /// passes through the data it contains.
+    ///
+    /// This specific example is also why `Pieces` has a `From` trait
+    /// implementation for `(Timestamp, Offset)`, which correspond more to
+    /// what you want:
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::Pieces, tz, Timestamp};
+    ///
+    /// let pieces = Pieces::from((Timestamp::UNIX_EPOCH, tz::offset(-5)));
+    /// assert_eq!(pieces.to_string(), "1969-12-31T19:00:00-05:00");
+    /// ```
+    ///
+    /// A decent mental model of `Pieces` is that setting fields on `Pieces`
+    /// can't change the values in memory of other fields.
+    ///
+    /// # Example: setting an offset forces a time to be written
+    ///
+    /// Consider these cases where formatting a `Pieces` won't write a
+    /// [`Time`]:
+    ///
+    /// ```
+    /// use jiff::fmt::temporal::Pieces;
+    ///
+    /// let pieces = Pieces::from(jiff::civil::date(2025, 1, 3));
+    /// assert_eq!(pieces.to_string(), "2025-01-03");
+    ///
+    /// let pieces = Pieces::from(jiff::civil::date(2025, 1, 3))
+    ///     .with_time_zone_name("Africa/Cairo");
+    /// assert_eq!(pieces.to_string(), "2025-01-03[Africa/Cairo]");
+    /// ```
+    ///
+    /// This works because the resulting strings are valid. In particular, when
+    /// one parses a `2025-01-03[Africa/Cairo]` into a `Zoned`, it results in a
+    /// time component of midnight automatically (or more precisely, the first
+    /// instead of the corresponding day):
+    ///
+    /// ```
+    /// use jiff::{civil::Time, Zoned};
+    ///
+    /// let zdt: Zoned = "2025-01-03[Africa/Cairo]".parse()?;
+    /// assert_eq!(zdt.time(), Time::midnight());
+    ///
+    /// // tricksy tricksy, the first instant of 2015-10-18 in Sao Paulo is
+    /// // not midnight!
+    /// let zdt: Zoned = "2015-10-18[America/Sao_Paulo]".parse()?;
+    /// assert_eq!(zdt.time(), jiff::civil::time(1, 0, 0, 0));
+    /// // This happens because midnight didn't appear on the clocks in
+    /// // Sao Paulo on 2015-10-18. So if you try to parse a datetime with
+    /// // midnight, automatic disambiguation kicks in and chooses the time
+    /// // after the gap automatically:
+    /// let zdt: Zoned = "2015-10-18T00:00:00[America/Sao_Paulo]".parse()?;
+    /// assert_eq!(zdt.time(), jiff::civil::time(1, 0, 0, 0));
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// However, if you have a date and an offset, then since things like
+    /// `2025-01-03+10` aren't valid Temporal ISO 8601 datetime strings, the
+    /// default midnight time is automatically written:
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::Pieces, tz};
+    ///
+    /// let pieces = Pieces::from(jiff::civil::date(2025, 1, 3))
+    ///     .with_offset(tz::offset(-5));
+    /// assert_eq!(pieces.to_string(), "2025-01-03T00:00:00-05:00");
+    ///
+    /// let pieces = Pieces::from(jiff::civil::date(2025, 1, 3))
+    ///     .with_offset(tz::offset(2))
+    ///     .with_time_zone_name("Africa/Cairo");
+    /// assert_eq!(pieces.to_string(), "2025-01-03T00:00:00+02:00[Africa/Cairo]");
+    /// ```
+    ///
+    /// # Example: formatting a Zulu or `-00:00` offset
+    ///
+    /// A [`PiecesOffset`] encapsulates not just a numeric offset, but also
+    /// whether a `Z` or a signed zero are used. While it's uncommon to need
+    /// this, this permits one to format a `Pieces` using either of these
+    /// constructs:
+    ///
+    /// ```
+    /// use jiff::{
+    ///     civil,
+    ///     fmt::temporal::{Pieces, PiecesNumericOffset, PiecesOffset},
+    ///     tz::Offset,
+    /// };
+    ///
+    /// let pieces = Pieces::from(civil::date(1970, 1, 1).at(0, 0, 0, 0))
+    ///     .with_offset(Offset::UTC);
+    /// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00+00:00");
+    ///
+    /// let pieces = Pieces::from(civil::date(1970, 1, 1).at(0, 0, 0, 0))
+    ///     .with_offset(PiecesOffset::Zulu);
+    /// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00Z");
+    ///
+    /// let pieces = Pieces::from(civil::date(1970, 1, 1).at(0, 0, 0, 0))
+    ///     .with_offset(PiecesNumericOffset::from(Offset::UTC).with_negative_zero());
+    /// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00-00:00");
+    /// ```
+    ///
+    /// [RFC 3339]: https://www.rfc-editor.org/rfc/rfc3339
+    #[inline]
+    pub fn with_offset<T: Into<PiecesOffset>>(self, offset: T) -> Pieces<'n> {
+        Pieces { offset: Some(offset.into()), ..self }
+    }
+
+    /// Sets the time zone annotation on this `Pieces` to the given time zone
+    /// name.
+    ///
+    /// Setting a time zone annotation on `Pieces` is optional.
+    ///
+    /// This is a convenience routine for using
+    /// [`Pieces::with_time_zone_annotation`] with an explicitly constructed
+    /// [`TimeZoneAnnotation`] for a time zone name.
+    ///
+    /// # Example
+    ///
+    /// This example shows how easily you can shoot yourself in the foot with
+    /// this routine:
+    ///
+    /// ```
+    /// use jiff::fmt::temporal::{Pieces, TimeZoneAnnotation};
+    ///
+    /// let mut pieces = Pieces::parse("2025-01-03T07:55+02[Africa/Cairo]")?;
+    /// pieces = pieces.with_time_zone_name("Australia/Bluey");
+    /// // This is nonsense because `Australia/Bluey` isn't a valid time zone!
+    /// assert_eq!(pieces.to_string(), "2025-01-03T07:55:00+02:00[Australia/Bluey]");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This exemplifies that `Pieces` is a mostly "dumb" type that passes
+    /// through the data it contains, even if it doesn't make sense.
+    #[inline]
+    pub fn with_time_zone_name<'a>(self, name: &'a str) -> Pieces<'a> {
+        self.with_time_zone_annotation(TimeZoneAnnotation::from(name))
+    }
+
+    /// Sets the time zone annotation on this `Pieces` to the given offset.
+    ///
+    /// Setting a time zone annotation on `Pieces` is optional.
+    ///
+    /// This is a convenience routine for using
+    /// [`Pieces::with_time_zone_annotation`] with an explicitly constructed
+    /// [`TimeZoneAnnotation`] for a time zone offset.
+    ///
+    /// Note that this is distinct from [`Pieces::with_offset`]. This
+    /// routine sets the offset inside the time zone annotation, while
+    /// `Pieces::with_offset` sets the offset on the timestamp itself. When the
+    /// timestamp offset and the time zone annotation offset are both present,
+    /// then they must be equivalent or else the datetime string is not a valid
+    /// Temporal ISO 8601 string. However, a `Pieces` will let you format a
+    /// string with mismatching offsets.
+    ///
+    /// # Example
+    ///
+    /// This example shows how easily you can shoot yourself in the foot with
+    /// this routine:
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::{Pieces, TimeZoneAnnotation}, tz};
+    ///
+    /// let mut pieces = Pieces::parse("2025-01-03T07:55+02[Africa/Cairo]")?;
+    /// pieces = pieces.with_time_zone_offset(tz::offset(-7));
+    /// // This is nonsense because the offset `+02` does not match `-07`.
+    /// assert_eq!(pieces.to_string(), "2025-01-03T07:55:00+02:00[-07:00]");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This exemplifies that `Pieces` is a mostly "dumb" type that passes
+    /// through the data it contains, even if it doesn't make sense.
+    #[inline]
+    pub fn with_time_zone_offset(self, offset: Offset) -> Pieces<'static> {
+        self.with_time_zone_annotation(TimeZoneAnnotation::from(offset))
+    }
+
+    /// Returns a new `Pieces` with the given time zone annotation.
+    ///
+    /// Setting a time zone annotation on `Pieces` is optional.
+    ///
+    /// You may find it more convenient to use
+    /// [`Pieces::with_time_zone_name`] or [`Pieces::with_time_zone_offset`].
+    ///
+    /// # Example
+    ///
+    /// This example shows how easily you can shoot yourself in the foot with
+    /// this routine:
+    ///
+    /// ```
+    /// use jiff::fmt::temporal::{Pieces, TimeZoneAnnotation};
+    ///
+    /// let mut pieces = Pieces::parse("2025-01-03T07:55+02[Africa/Cairo]")?;
+    /// pieces = pieces.with_time_zone_annotation(
+    ///     TimeZoneAnnotation::from("Canada/Yukon"),
+    /// );
+    /// // This is nonsense because the offset `+02` is never valid for the
+    /// // `Canada/Yukon` time zone.
+    /// assert_eq!(pieces.to_string(), "2025-01-03T07:55:00+02:00[Canada/Yukon]");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// This exemplifies that `Pieces` is a mostly "dumb" type that passes
+    /// through the data it contains, even if it doesn't make sense.
+    #[inline]
+    pub fn with_time_zone_annotation<'a>(
+        self,
+        ann: TimeZoneAnnotation<'a>,
+    ) -> Pieces<'a> {
+        Pieces { time_zone_annotation: Some(ann), ..self }
+    }
+
+    /// Converts this `Pieces` into an "owned" value whose lifetime is
+    /// `'static`.
+    ///
+    /// Ths "owned" value in this context refers to the time zone annotation
+    /// name, if present. For example, `Canada/Yukon` in
+    /// `2025-01-03T07:55-07[Canada/Yukon]`. When parsing into a `Pieces`,
+    /// the time zone annotation name is borrowed. But callers may find it more
+    /// convenient to work with an owned value. By calling this method, the
+    /// borrowed string internally will be copied into a new string heap
+    /// allocation.
+    ///
+    /// If `Pieces` doesn't have a time zone annotation, is already owned or
+    /// the time zone annotation is an offset, then this is a no-op.
+    #[cfg(feature = "alloc")]
+    #[inline]
+    pub fn into_owned(self) -> Pieces<'static> {
+        Pieces {
+            date: self.date,
+            time: self.time,
+            offset: self.offset,
+            time_zone_annotation: self
+                .time_zone_annotation
+                .map(|ann| ann.into_owned()),
+        }
+    }
+}
+
+impl From<Date> for Pieces<'static> {
+    #[inline]
+    fn from(date: Date) -> Pieces<'static> {
+        Pieces { date, time: None, offset: None, time_zone_annotation: None }
+    }
+}
+
+impl From<DateTime> for Pieces<'static> {
+    #[inline]
+    fn from(dt: DateTime) -> Pieces<'static> {
+        Pieces::from(dt.date()).with_time(dt.time())
+    }
+}
+
+impl From<Timestamp> for Pieces<'static> {
+    #[inline]
+    fn from(ts: Timestamp) -> Pieces<'static> {
+        let dt = Offset::UTC.to_datetime(ts);
+        Pieces::from(dt).with_offset(PiecesOffset::Zulu)
+    }
+}
+
+impl From<(Timestamp, Offset)> for Pieces<'static> {
+    #[inline]
+    fn from((ts, offset): (Timestamp, Offset)) -> Pieces<'static> {
+        Pieces::from(offset.to_datetime(ts)).with_offset(offset)
+    }
+}
+
+impl<'a> From<&'a Zoned> for Pieces<'a> {
+    #[inline]
+    fn from(zdt: &'a Zoned) -> Pieces<'a> {
+        let mut pieces =
+            Pieces::from(zdt.datetime()).with_offset(zdt.offset());
+        if let Some(name) = zdt.time_zone().iana_name() {
+            pieces = pieces.with_time_zone_name(name);
+        } else {
+            pieces = pieces.with_time_zone_offset(zdt.offset());
+        }
+        pieces
+    }
+}
+
+impl<'n> core::fmt::Display for Pieces<'n> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        use crate::fmt::StdFmtWrite;
+
+        let precision =
+            f.precision().map(|p| u8::try_from(p).unwrap_or(u8::MAX));
+        super::DateTimePrinter::new()
+            .precision(precision)
+            .print_pieces(self, StdFmtWrite(f))
+            .map_err(|_| core::fmt::Error)
+    }
+}
+
+/// An offset parsed from a Temporal ISO 8601 datetime string, for use with
+/// [`Pieces`].
+///
+/// One can almost think of this as effectively equivalent to an `Offset`. And
+/// indeed, all `PiecesOffset` values can be convert to an `Offset`. However,
+/// some offsets in a datetime string have a different connotation that can't
+/// be captured by an `Offset`.
+///
+/// For example, the offsets `Z`, `-00:00` and `+00:00` all map to
+/// [`Offset::UTC`] after parsing. However, `Z` and `-00:00` generally
+/// indicate that the offset from local time is unknown, where as `+00:00`
+/// indicates that the offset from local is _known_ and is zero. This type
+/// permits callers to inspect what offset was actually written.
+///
+/// # Example
+///
+/// This example shows how one can create Temporal ISO 8601 datetime strings
+/// with `+00:00`, `-00:00` or `Z` offsets.
+///
+/// ```
+/// use jiff::{
+///     fmt::temporal::{Pieces, PiecesNumericOffset},
+///     tz::Offset,
+///     Timestamp,
+/// };
+///
+/// // If you create a `Pieces` from a `Timestamp` with a UTC offset,
+/// // then this is interpreted as "the offset from UTC is known and is
+/// // zero."
+/// let pieces = Pieces::from((Timestamp::UNIX_EPOCH, Offset::UTC));
+/// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00+00:00");
+///
+/// // Otherwise, if you create a `Pieces` from just a `Timestamp` with
+/// // no offset, then it is interpreted as "the offset from UTC is not
+/// // known." Typically, this is rendered with `Z` for "Zulu":
+/// let pieces = Pieces::from(Timestamp::UNIX_EPOCH);
+/// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00Z");
+///
+/// // But it might be the case that you want to use `-00:00` instead,
+/// // perhaps to conform to some existing convention or legacy
+/// // applications that require it:
+/// let pieces = Pieces::from(Timestamp::UNIX_EPOCH)
+///     .with_offset(
+///         PiecesNumericOffset::from(Offset::UTC).with_negative_zero(),
+///     );
+/// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00-00:00");
+/// ```
+///
+/// Without `Pieces`, it's not otherwise possible to emit a `-00:00` offset.
+/// For example,
+/// [`DateTimePrinter::print_timestamp`](crate::fmt::temporal::DateTimePrinter::print_timestamp)
+/// will always emit `Z`, which is consider semantically identical to `-00:00`
+/// by [RFC 9557]. There's no specific use case where it's expected that you
+/// should need to write `-00:00` instead of `Z`, but it's conceivable legacy
+/// or otherwise inflexible applications might want it. Or perhaps, in some
+/// systems, there is a distinction to draw between `Z` and `-00:00`.
+///
+/// [RFC 9557]: https://www.rfc-editor.org/rfc/rfc9557.html
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[non_exhaustive]
+pub enum PiecesOffset {
+    /// The "Zulu" offset, corresponding to UTC in a context where the offset
+    /// for civil time is unknown or unavailable.
+    ///
+    /// [RFC 9557] defines this as equivalent in semantic meaning to `-00:00`:
+    ///
+    /// > If the time in UTC is known, but the offset to local time is unknown,
+    /// > this can be represented with an offset of `Z`. (The original version
+    /// > of this specification provided `-00:00` for this purpose, which is
+    /// > not allowed by ISO-8601:2000 and therefore is less interoperable;
+    /// > Section 3.3 of RFC 5322 describes a related convention for email,
+    /// > which does not have this problem). This differs semantically from an
+    /// > offset of `+00:00`, which implies that UTC is the preferred reference
+    /// > point for the specified time.
+    ///
+    /// [RFC 9557]: https://www.rfc-editor.org/rfc/rfc9557
+    Zulu,
+    /// A specific numeric offset, including whether the parsed sign is
+    /// negative.
+    ///
+    /// The sign is usually redundant, since an `Offset` is itself signed. But
+    /// it can be used to distinguish between `+00:00` (`+00` is the preferred
+    /// offset) and `-00:00` (`+00` is what should be used, but only because
+    /// the offset to local time is not known). Generally speaking, one should
+    /// regard `-00:00` as equivalent to `Z`, per RFC 9557.
+    Numeric(PiecesNumericOffset),
+}
+
+impl PiecesOffset {
+    /// Converts this offset to a concrete numeric offset in all cases.
+    ///
+    /// If this was a `Z` or a `-00:00` offset, then `Offset::UTC` is returned.
+    /// In all other cases, the underlying numeric offset is returned as-is.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{
+    ///     fmt::temporal::{Pieces, PiecesNumericOffset, PiecesOffset},
+    ///     tz::Offset,
+    /// };
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00Z")?;
+    /// let off = pieces.offset().unwrap();
+    /// // Parsed as Zulu.
+    /// assert_eq!(off, PiecesOffset::Zulu);
+    /// // Gets converted from Zulu to UTC, i.e., just zero.
+    /// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00-00:00")?;
+    /// let off = pieces.offset().unwrap();
+    /// // Parsed as a negative zero.
+    /// assert_eq!(off, PiecesOffset::from(
+    ///     PiecesNumericOffset::from(Offset::UTC).with_negative_zero(),
+    /// ));
+    /// // Gets converted from -00:00 to UTC, i.e., just zero.
+    /// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00+00:00")?;
+    /// let off = pieces.offset().unwrap();
+    /// // Parsed as a positive zero.
+    /// assert_eq!(off, PiecesOffset::from(
+    ///     PiecesNumericOffset::from(Offset::UTC),
+    /// ));
+    /// // Gets converted from -00:00 to UTC, i.e., just zero.
+    /// assert_eq!(off.to_numeric_offset(), Offset::UTC);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_numeric_offset(&self) -> Offset {
+        match *self {
+            PiecesOffset::Zulu => Offset::UTC,
+            // -00:00 and +00:00 both collapse to zero here.
+            PiecesOffset::Numeric(ref noffset) => noffset.offset(),
+        }
+    }
+}
+
+impl From<Offset> for PiecesOffset {
+    #[inline]
+    fn from(offset: Offset) -> PiecesOffset {
+        PiecesOffset::from(PiecesNumericOffset::from(offset))
+    }
+}
+
+impl From<PiecesNumericOffset> for PiecesOffset {
+    #[inline]
+    fn from(offset: PiecesNumericOffset) -> PiecesOffset {
+        PiecesOffset::Numeric(offset)
+    }
+}
+
+/// A specific numeric offset, including the sign of the offset, for use with
+/// [`Pieces`].
+///
+/// # Signedness
+///
+/// The sign attached to this type is usually redundant, since the underlying
+/// [`Offset`] is itself signed. But it can be used to distinguish between
+/// `+00:00` (`+00` is the preferred offset) and `-00:00` (`+00` is what should
+/// be used, but only because the offset to local time is not known). Generally
+/// speaking, one should regard `-00:00` as equivalent to `Z`, per [RFC 9557].
+///
+/// [RFC 9557]: https://www.rfc-editor.org/rfc/rfc9557
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct PiecesNumericOffset {
+    offset: Offset,
+    is_negative: bool,
+}
+
+impl PiecesNumericOffset {
+    /// Returns the numeric offset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{
+    ///     fmt::temporal::{Pieces, PiecesOffset},
+    ///     tz::Offset,
+    /// };
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00-05:30")?;
+    /// let off = match pieces.offset().unwrap() {
+    ///     PiecesOffset::Numeric(off) => off,
+    ///     _ => unreachable!(),
+    /// };
+    /// // This is really only useful if you care that an actual
+    /// // numeric offset was written and not, e.g., `Z`. Otherwise,
+    /// // you could just use `PiecesOffset::to_numeric_offset`.
+    /// assert_eq!(
+    ///     off.offset(),
+    ///     Offset::from_seconds(-5 * 60 * 60 - 30 * 60).unwrap(),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn offset(&self) -> Offset {
+        self.offset
+    }
+
+    /// Returns whether the sign of the offset is negative or not.
+    ///
+    /// When formatting a [`Pieces`] to a string, this is _only_ used to
+    /// determine the rendered sign when the [`Offset`] is itself zero. In
+    /// all other cases, the sign rendered matches the sign of the `Offset`.
+    ///
+    /// Since `Offset` does not keep track of a sign when its value is zero,
+    /// when using the `From<Offset>` trait implementation for this type,
+    /// `is_negative` is always set to `false` when the offset is zero.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{
+    ///     fmt::temporal::{Pieces, PiecesOffset},
+    ///     tz::Offset,
+    /// };
+    ///
+    /// let pieces = Pieces::parse("1970-01-01T00:00:00-00:00")?;
+    /// let off = match pieces.offset().unwrap() {
+    ///     PiecesOffset::Numeric(off) => off,
+    ///     _ => unreachable!(),
+    /// };
+    /// // The numeric offset component in this case is
+    /// // indistiguisable from `Offset::UTC`. This is
+    /// // because an `Offset` does not use different
+    /// // representations for negative and positive zero.
+    /// assert_eq!(off.offset(), Offset::UTC);
+    /// // This is where `is_negative` comes in handy:
+    /// assert_eq!(off.is_negative(), true);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_negative(&self) -> bool {
+        self.is_negative
+    }
+
+    /// Sets this numeric offset to use `-00:00` if and only if the offset
+    /// is zero.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{
+    ///     fmt::temporal::{Pieces, PiecesNumericOffset},
+    ///     tz::Offset,
+    ///     Timestamp,
+    /// };
+    ///
+    /// // If you create a `Pieces` from a `Timestamp` with a UTC offset,
+    /// // then this is interpreted as "the offset from UTC is known and is
+    /// // zero."
+    /// let pieces = Pieces::from((Timestamp::UNIX_EPOCH, Offset::UTC));
+    /// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00+00:00");
+    ///
+    /// // Otherwise, if you create a `Pieces` from just a `Timestamp` with
+    /// // no offset, then it is interpreted as "the offset from UTC is not
+    /// // known." Typically, this is rendered with `Z` for "Zulu":
+    /// let pieces = Pieces::from(Timestamp::UNIX_EPOCH);
+    /// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00Z");
+    ///
+    /// // But it might be the case that you want to use `-00:00` instead,
+    /// // perhaps to conform to some existing convention or legacy
+    /// // applications that require it:
+    /// let pieces = Pieces::from(Timestamp::UNIX_EPOCH)
+    ///     .with_offset(
+    ///         PiecesNumericOffset::from(Offset::UTC).with_negative_zero(),
+    ///     );
+    /// assert_eq!(pieces.to_string(), "1970-01-01T00:00:00-00:00");
+    /// ```
+    #[inline]
+    pub fn with_negative_zero(self) -> PiecesNumericOffset {
+        PiecesNumericOffset { is_negative: true, ..self }
+    }
+}
+
+impl From<Offset> for PiecesNumericOffset {
+    #[inline]
+    fn from(offset: Offset) -> PiecesNumericOffset {
+        // This can of course never return a -00:00 offset, only +00:00.
+        PiecesNumericOffset { offset, is_negative: offset.is_negative() }
+    }
+}
+
+/// An [RFC 9557] time zone annotation, for use with [`Pieces`].
+///
+/// A time zone annotation is either a time zone name (typically an IANA time
+/// zone identifier) like `America/New_York`, or an offset like `-05:00`. This
+/// is normally an implementation detail of parsing into a [`Zoned`], but the
+/// raw annotation can be accessed via [`Pieces::time_zone_annotation`] after
+/// parsing into a [`Pieces`].
+///
+/// The lifetime parameter refers to the lifetime of the time zone
+/// name. The lifetime is static when the time zone annotation is
+/// offset or if the name is owned. An owned value can be produced via
+/// [`TimeZoneAnnotation::into_owned`] when the `alloc` crate feature is
+/// enabled.
+///
+/// # Construction
+///
+/// If you're using [`Pieces`], then its [`Pieces::with_time_zone_name`] and
+/// [`Pieces::with_time_zone_offset`] methods should absolve you of needing to
+/// build values of this type explicitly. But if the need arises, there are
+/// `From` impls for `&str` (time zone annotation name) and [`Offset`] (time
+/// zone annotation offset) for this type.
+///
+/// # Example
+///
+/// ```
+/// use jiff::{fmt::temporal::{Pieces, TimeZoneAnnotation}, tz::offset};
+///
+/// // A time zone annotation from a name:
+/// let pieces = Pieces::parse("2025-01-02T16:47-05[America/New_York]")?;
+/// assert_eq!(
+///     pieces.time_zone_annotation().unwrap(),
+///     &TimeZoneAnnotation::from("America/New_York"),
+/// );
+///
+/// // A time zone annotation from an offset:
+/// let pieces = Pieces::parse("2025-01-02T16:47-05[-05:00]")?;
+/// assert_eq!(
+///     pieces.time_zone_annotation().unwrap(),
+///     &TimeZoneAnnotation::from(offset(-5)),
+/// );
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// [RFC 9557]: https://www.rfc-editor.org/rfc/rfc9557.html
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct TimeZoneAnnotation<'n> {
+    pub(crate) kind: TimeZoneAnnotationKind<'n>,
+    /// Whether the annotation is marked as "critical," i.e., with a
+    /// `!` prefix. When enabled, it's supposed to make the annotation
+    /// un-ignorable.
+    ///
+    /// This is basically unused. And there's no way for callers to flip this
+    /// switch currently. But it can be queried after parsing. Jiff also
+    /// doesn't alter its behavior based on this flag. In particular, Jiff
+    /// basically always behaves as if `critical` is true.
+    pub(crate) critical: bool,
+}
+
+impl<'n> TimeZoneAnnotation<'n> {
+    /// Returns the "kind" of this annotation. The kind is either a name or an
+    /// offset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::fmt::temporal::{Pieces, TimeZoneAnnotation};
+    ///
+    /// // A time zone annotation from a name, which doesn't necessarily have
+    /// // to point to a valid IANA time zone.
+    /// let pieces = Pieces::parse("2025-01-02T16:47-05[Australia/Bluey]")?;
+    /// assert_eq!(
+    ///     pieces.time_zone_annotation().unwrap(),
+    ///     &TimeZoneAnnotation::from("Australia/Bluey"),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn kind(&self) -> &TimeZoneAnnotationKind<'n> {
+        &self.kind
+    }
+
+    /// Returns true when this time zone is marked as "critical." This occurs
+    /// when the time zone annotation is preceded by a `!`. It is meant to
+    /// signify that, basically, implementations should error if the annotation
+    /// is invalid in some way. And when it's absent, it's left up to the
+    /// implementation's discretion about what to do (including silently
+    /// ignoring the invalid annotation).
+    ///
+    /// Generally speaking, Jiff ignores this altogether for time zone
+    /// annotations and behaves as if it's always true. But it's exposed here
+    /// for callers to query in case it's useful.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::fmt::temporal::{Pieces, TimeZoneAnnotation};
+    ///
+    /// // not critical
+    /// let pieces = Pieces::parse("2025-01-02T16:47-05[Australia/Bluey]")?;
+    /// assert_eq!(
+    ///     Some(false),
+    ///     pieces.time_zone_annotation().map(|a| a.is_critical()),
+    /// );
+    ///
+    /// // critical
+    /// let pieces = Pieces::parse("2025-01-02T16:47-05[!Australia/Bluey]")?;
+    /// assert_eq!(
+    ///     Some(true),
+    ///     pieces.time_zone_annotation().map(|a| a.is_critical()),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn is_critical(&self) -> bool {
+        self.critical
+    }
+
+    /// A convenience routine for converting this annotation into a time zone.
+    ///
+    /// This can fail if the annotation contains a name that couldn't be found
+    /// in the global time zone database. If you need to use something other
+    /// than the global time zone database, then use
+    /// [`TimeZoneAnnotation::to_time_zone_with`].
+    ///
+    /// Note that it may be more convenient to use
+    /// [`Pieces::to_time_zone`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::Pieces, tz::TimeZone};
+    ///
+    /// let pieces = Pieces::parse("2025-01-02T16:47-05[Australia/Tasmania]")?;
+    /// let ann = pieces.time_zone_annotation().unwrap();
+    /// assert_eq!(
+    ///     ann.to_time_zone().unwrap(),
+    ///     TimeZone::get("Australia/Tasmania").unwrap(),
+    /// );
+    ///
+    /// let pieces = Pieces::parse("2025-01-02T16:47-05[Australia/Bluey]")?;
+    /// let ann = pieces.time_zone_annotation().unwrap();
+    /// assert_eq!(
+    ///     ann.to_time_zone().unwrap_err().to_string(),
+    ///     "failed to find time zone `Australia/Bluey` in time zone database",
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_time_zone(&self) -> Result<TimeZone, Error> {
+        self.to_time_zone_with(crate::tz::db())
+    }
+
+    /// This is like [`TimeZoneAnnotation::to_time_zone`], but permits the
+    /// caller to pass in their own time zone database.
+    ///
+    /// This can fail if the annotation contains a name that couldn't be found
+    /// in the global time zone database. If you need to use something other
+    /// than the global time zone database, then use
+    /// [`TimeZoneAnnotation::to_time_zone_with`].
+    ///
+    /// Note that it may be more convenient to use
+    /// [`Pieces::to_time_zone_with`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{fmt::temporal::Pieces, tz::TimeZone};
+    ///
+    /// let pieces = Pieces::parse("2025-01-02T16:47-05[Australia/Tasmania]")?;
+    /// let ann = pieces.time_zone_annotation().unwrap();
+    /// assert_eq!(
+    ///     ann.to_time_zone_with(jiff::tz::db()).unwrap(),
+    ///     TimeZone::get("Australia/Tasmania").unwrap(),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_time_zone_with(
+        &self,
+        db: &TimeZoneDatabase,
+    ) -> Result<TimeZone, Error> {
+        // NOTE: We don't currently utilize the critical flag here. Temporal
+        // seems to ignore it. It's not quite clear what else we'd do with it,
+        // particularly given that we provide a way to do conflict resolution
+        // between offsets and time zones.
+        let tz = match *self.kind() {
+            TimeZoneAnnotationKind::Named(ref name) => {
+                db.get(name.as_str())?
+            }
+            TimeZoneAnnotationKind::Offset(offset) => TimeZone::fixed(offset),
+        };
+        Ok(tz)
+    }
+
+    /// Converts this time zone annotation into an "owned" value whose lifetime
+    /// is `'static`.
+    ///
+    /// If this was already an "owned" value or a time zone annotation offset,
+    /// then this is a no-op.
+    #[cfg(feature = "alloc")]
+    #[inline]
+    pub fn into_owned(self) -> TimeZoneAnnotation<'static> {
+        TimeZoneAnnotation {
+            kind: self.kind.into_owned(),
+            critical: self.critical,
+        }
+    }
+}
+
+impl<'n> From<&'n str> for TimeZoneAnnotation<'n> {
+    fn from(string: &'n str) -> TimeZoneAnnotation<'n> {
+        let kind = TimeZoneAnnotationKind::from(string);
+        TimeZoneAnnotation { kind, critical: false }
+    }
+}
+
+impl From<Offset> for TimeZoneAnnotation<'static> {
+    fn from(offset: Offset) -> TimeZoneAnnotation<'static> {
+        let kind = TimeZoneAnnotationKind::from(offset);
+        TimeZoneAnnotation { kind, critical: false }
+    }
+}
+
+/// The kind of time zone found in an [RFC 9557] timestamp, for use with
+/// [`Pieces`].
+///
+/// The lifetime parameter refers to the lifetime of the time zone
+/// name. The lifetime is static when the time zone annotation is
+/// offset or if the name is owned. An owned value can be produced via
+/// [`TimeZoneAnnotation::into_owned`] when the `alloc` crate feature is
+/// enabled.
+///
+/// [RFC 9557]: https://www.rfc-editor.org/rfc/rfc9557.html
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+#[non_exhaustive]
+pub enum TimeZoneAnnotationKind<'n> {
+    /// The time zone annotation is a name, usually an IANA time zone
+    /// identifier. For example, `America/New_York`.
+    Named(TimeZoneAnnotationName<'n>),
+    /// The time zone annotation is an offset. For example, `-05:00`.
+    Offset(Offset),
+}
+
+impl<'n> TimeZoneAnnotationKind<'n> {
+    /// Converts this time zone annotation kind into an "owned" value whose
+    /// lifetime is `'static`.
+    ///
+    /// If this was already an "owned" value or a time zone annotation offset,
+    /// then this is a no-op.
+    #[cfg(feature = "alloc")]
+    #[inline]
+    pub fn into_owned(self) -> TimeZoneAnnotationKind<'static> {
+        match self {
+            TimeZoneAnnotationKind::Named(named) => {
+                TimeZoneAnnotationKind::Named(named.into_owned())
+            }
+            TimeZoneAnnotationKind::Offset(offset) => {
+                TimeZoneAnnotationKind::Offset(offset)
+            }
+        }
+    }
+}
+
+impl<'n> From<&'n str> for TimeZoneAnnotationKind<'n> {
+    fn from(string: &'n str) -> TimeZoneAnnotationKind<'n> {
+        let name = TimeZoneAnnotationName::from(string);
+        TimeZoneAnnotationKind::Named(name)
+    }
+}
+
+impl From<Offset> for TimeZoneAnnotationKind<'static> {
+    fn from(offset: Offset) -> TimeZoneAnnotationKind<'static> {
+        TimeZoneAnnotationKind::Offset(offset)
+    }
+}
+
+/// A time zone annotation parsed from a datetime string.
+///
+/// By default, a time zone annotation name borrows its name from the
+/// input it was parsed from. When the `alloc` feature is enabled,
+/// callers can de-couple the annotation from the parsed input with
+/// [`TimeZoneAnnotationName::into_owned`].
+///
+/// A value of this type is usually found via [`Pieces::time_zone_annotation`],
+/// but callers can also construct one via this type's `From<&str>` trait
+/// implementation if necessary.
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct TimeZoneAnnotationName<'n> {
+    name: StringCow<'n>,
+}
+
+impl<'n> TimeZoneAnnotationName<'n> {
+    /// Returns the name of this time zone annotation as a string slice.
+    ///
+    /// Note that the lifetime of the string slice returned is tied to the
+    /// lifetime of this time zone annotation. This may be shorter than the
+    /// lifetime of the string, `'n`, in this annotation.
+    #[inline]
+    pub fn as_str<'a>(&'a self) -> &'a str {
+        self.name.as_str()
+    }
+
+    /// Converts this time zone annotation name into an "owned" value whose
+    /// lifetime is `'static`.
+    ///
+    /// If this was already an "owned" value, then this is a no-op.
+    #[cfg(feature = "alloc")]
+    #[inline]
+    pub fn into_owned(self) -> TimeZoneAnnotationName<'static> {
+        TimeZoneAnnotationName { name: self.name.into_owned() }
+    }
+}
+
+impl<'n> From<&'n str> for TimeZoneAnnotationName<'n> {
+    fn from(string: &'n str) -> TimeZoneAnnotationName<'n> {
+        TimeZoneAnnotationName { name: StringCow::from(string) }
+    }
+}
diff --git a/src/fmt/temporal/printer.rs b/src/fmt/temporal/printer.rs
index 0597c3c9..2e8aa81e 100644
--- a/src/fmt/temporal/printer.rs
+++ b/src/fmt/temporal/printer.rs
@@ -2,6 +2,7 @@ use crate::{
     civil::{Date, DateTime, Time},
     error::Error,
     fmt::{
+        temporal::{Pieces, PiecesOffset, TimeZoneAnnotationKind},
         util::{DecimalFormatter, FractionalFormatter},
         Write, WriteExt,
     },
@@ -143,6 +144,73 @@ impl DateTimePrinter {
         Ok(())
     }
 
+    pub(super) fn print_pieces<W: Write>(
+        &self,
+        pieces: &Pieces,
+        mut wtr: W,
+    ) -> Result<(), Error> {
+        if let Some(time) = pieces.time() {
+            let dt = DateTime::from_parts(pieces.date(), time);
+            self.print_datetime(&dt, &mut wtr)?;
+            if let Some(poffset) = pieces.offset() {
+                self.print_pieces_offset(&poffset, &mut wtr)?;
+            }
+        } else if let Some(poffset) = pieces.offset() {
+            // In this case, we have an offset but no time component. Since
+            // `2025-01-02-05:00` isn't valid, we forcefully write out the
+            // default time (which is what would be assumed anyway).
+            let dt = DateTime::from_parts(pieces.date(), Time::midnight());
+            self.print_datetime(&dt, &mut wtr)?;
+            self.print_pieces_offset(&poffset, &mut wtr)?;
+        } else {
+            // We have no time and no offset, so we can just write the date.
+            // It's okay to write this followed by an annotation, e.g.,
+            // `2025-01-02[America/New_York]` or even `2025-01-02[-05:00]`.
+            self.print_date(&pieces.date(), &mut wtr)?;
+        }
+        // For the time zone annotation, a `Pieces` gives us the annotation
+        // name or offset directly, where as with `Zoned`, we have a
+        // `TimeZone`. So we hand-roll our own formatter directly from the
+        // annotation.
+        if let Some(ann) = pieces.time_zone_annotation() {
+            // Note that we explicitly ignore `self.rfc9557` here, since with
+            // `Pieces`, the annotation has been explicitly provided. Also,
+            // at time of writing, `self.rfc9557` is always enabled anyway.
+            wtr.write_str("[")?;
+            if ann.is_critical() {
+                wtr.write_str("!")?;
+            }
+            match *ann.kind() {
+                TimeZoneAnnotationKind::Named(ref name) => {
+                    wtr.write_str(name.as_str())?
+                }
+                TimeZoneAnnotationKind::Offset(offset) => {
+                    self.print_offset(&offset, &mut wtr)?
+                }
+            }
+            wtr.write_str("]")?;
+        }
+        Ok(())
+    }
+
+    /// Formats the given "pieces" offset into the writer given.
+    fn print_pieces_offset<W: Write>(
+        &self,
+        poffset: &PiecesOffset,
+        mut wtr: W,
+    ) -> Result<(), Error> {
+        match *poffset {
+            PiecesOffset::Zulu => self.print_zulu(wtr),
+            PiecesOffset::Numeric(ref noffset) => {
+                if noffset.offset().is_zero() && noffset.is_negative() {
+                    wtr.write_str("-00:00")
+                } else {
+                    self.print_offset(&noffset.offset(), wtr)
+                }
+            }
+        }
+    }
+
     /// Formats the given offset into the writer given.
     fn print_offset<W: Write>(
         &self,
diff --git a/src/lib.rs b/src/lib.rs
index 79b9392f..323e886a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -44,9 +44,10 @@ All three of these components are used to provide convenient high level
 operations on `Zoned` such as computing durations, adding durations and
 rounding.
 
-This crate defines a single duration type, [`Span`], which mixes calendar
-and clock units into a single type. All datetime types in Jiff use spans for
-operating on durations.
+A [`Span`] is this crate's primary duration type. It mixes calendar and clock
+units into a single type. Jiff also provides [`SignedDuration`], which is like
+[`std::time::Duration`], but signed. Users should default to a `Span` for
+representing durations when using Jiff.
 
 [Unix epoch]: https://en.wikipedia.org/wiki/Unix_time
 [UTC]: https://en.wikipedia.org/wiki/Coordinated_Universal_Time
diff --git a/src/tz/offset.rs b/src/tz/offset.rs
index a4d9c97d..1a2f4708 100644
--- a/src/tz/offset.rs
+++ b/src/tz/offset.rs
@@ -343,6 +343,42 @@ impl Offset {
         Offset { span: -self.span }
     }
 
+    /// Returns the "sign number" or "signum" of this offset.
+    ///
+    /// The number returned is `-1` when this offset is negative,
+    /// `0` when this offset is zero and `1` when this span is positive.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::tz;
+    ///
+    /// assert_eq!(tz::offset(5).signum(), 1);
+    /// assert_eq!(tz::offset(0).signum(), 0);
+    /// assert_eq!(tz::offset(-5).signum(), -1);
+    /// ```
+    #[inline]
+    pub fn signum(self) -> i8 {
+        t::Sign::rfrom(self.span.signum()).get()
+    }
+
+    /// Returns true if and only if this offset is positive.
+    ///
+    /// This returns false when the offset is zero or negative.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::tz;
+    ///
+    /// assert!(tz::offset(5).is_positive());
+    /// assert!(!tz::offset(0).is_positive());
+    /// assert!(!tz::offset(-5).is_positive());
+    /// ```
+    pub fn is_positive(self) -> bool {
+        self.seconds_ranged() > 0
+    }
+
     /// Returns true if and only if this offset is less than zero.
     ///
     /// # Example
@@ -358,6 +394,23 @@ impl Offset {
         self.seconds_ranged() < 0
     }
 
+    /// Returns true if and only if this offset is zero.
+    ///
+    /// Or equivalently, when this offset corresponds to [`Offset::UTC`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::tz;
+    ///
+    /// assert!(!tz::offset(5).is_zero());
+    /// assert!(tz::offset(0).is_zero());
+    /// assert!(!tz::offset(-5).is_zero());
+    /// ```
+    pub fn is_zero(self) -> bool {
+        self.seconds_ranged() == 0
+    }
+
     /// Converts this offset into a [`TimeZone`].
     ///
     /// This is a convenience function for calling [`TimeZone::fixed`] with
@@ -1343,6 +1396,9 @@ pub enum OffsetConflict {
     /// unless the offset is invalid for the provided time zone. In that case,
     /// use the time zone. When the time zone is used, it's possible for an
     /// ambiguous datetime to be returned.
+    ///
+    /// See [`ZonedWith::offset_conflict`](crate::ZonedWith::offset_conflict)
+    /// for an example of when this strategy is useful.
     PreferOffset,
     /// When the offset and time zone are in conflict, this strategy always
     /// results in conflict resolution returning an error.
diff --git a/src/util/borrow.rs b/src/util/borrow.rs
index dd96a71e..21bda661 100644
--- a/src/util/borrow.rs
+++ b/src/util/borrow.rs
@@ -29,3 +29,69 @@ impl<'a, T: core::fmt::Display> core::fmt::Display for DumbCow<'a, T> {
         core::fmt::Display::fmt(core::ops::Deref::deref(self), f)
     }
 }
+
+/// A `Cow`, but can be used in core-only mode.
+///
+/// In core-only, the `Owned` variant doesn't exist.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub(crate) enum StringCow<'a> {
+    #[cfg(feature = "alloc")]
+    Owned(alloc::string::String),
+    Borrowed(&'a str),
+}
+
+impl<'a> StringCow<'a> {
+    /// Returns this `String` or `&str` as a `&str`.
+    ///
+    /// Like `std::borrow::Cow`, the lifetime of the string slice returned
+    /// is tied to `StringCow`, and _not_ the original lifetime of the string
+    /// slice.
+    pub(crate) fn as_str<'s>(&'s self) -> &'s str {
+        match *self {
+            #[cfg(feature = "alloc")]
+            StringCow::Owned(ref s) => s,
+            StringCow::Borrowed(s) => s,
+        }
+    }
+
+    /// Converts this cow into an "owned" variant, copying if necessary.
+    ///
+    /// If this cow is already an "owned" variant, then this is a no-op.
+    #[cfg(feature = "alloc")]
+    pub(crate) fn into_owned(self) -> StringCow<'static> {
+        use alloc::string::ToString;
+
+        match self {
+            StringCow::Owned(string) => StringCow::Owned(string),
+            StringCow::Borrowed(string) => {
+                StringCow::Owned(string.to_string())
+            }
+        }
+    }
+}
+
+impl<'a> core::ops::Deref for StringCow<'a> {
+    type Target = str;
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'a> core::fmt::Display for StringCow<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::Display::fmt(self.as_str(), f)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl From<alloc::string::String> for StringCow<'static> {
+    fn from(string: alloc::string::String) -> StringCow<'static> {
+        StringCow::Owned(string)
+    }
+}
+
+impl<'a> From<&'a str> for StringCow<'a> {
+    fn from(string: &'a str) -> StringCow<'a> {
+        StringCow::Borrowed(string)
+    }
+}
diff --git a/src/zoned.rs b/src/zoned.rs
index 2ae7fd27..8f8ce28e 100644
--- a/src/zoned.rs
+++ b/src/zoned.rs
@@ -496,8 +496,8 @@ impl Zoned {
     /// Create a builder for constructing a new `DateTime` from the fields of
     /// this datetime.
     ///
-    /// See the methods on [`DateTimeWith`] for the different ways one can set
-    /// the fields of a new `DateTime`.
+    /// See the methods on [`ZonedWith`] for the different ways one can set
+    /// the fields of a new `Zoned`.
     ///
     /// Note that this doesn't support changing the time zone. If you want a
     /// `Zoned` value of the same instant but in a different time zone, use
@@ -5038,10 +5038,6 @@ impl ZonedWith {
     /// let zdt2 = zdt1.with().hour(0).build()?;
     /// assert_eq!(
     ///     zdt2.to_string(),
-    ///     // Without taking the offset of the `Zoned` value into account,
-    ///     // this would have defaulted to using the "compatible"
-    ///     // disambiguation strategy, which would have selected the earlier
-    ///     // offset of -04 instead of sticking with the later offset of -05.
     ///     "2024-11-03T00:30:00-04:00[America/New_York]",
     /// );
     ///

From edb720ca0d448f157f4a3313467f8fe8abf269df Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Fri, 3 Jan 2025 22:23:05 -0500
Subject: [PATCH 6/9] 0.1.20

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 3bc27d81..82e80dcf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "jiff"
-version = "0.1.19"  #:version
+version = "0.1.20"  #:version
 authors = ["Andrew Gallant <jamslam@gmail.com>"]
 license = "Unlicense OR MIT"
 repository = "https://github.com/BurntSushi/jiff"

From 5e3dc49b34bca608e49221450eac30b6310a4373 Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Sat, 4 Jan 2025 11:09:13 -0500
Subject: [PATCH 7/9] fmt/friendly: add "zero unit" option

This adds a new option for configuring the unit to use when formatting a
zero span or duration.

Closes #192
---
 CHANGELOG.md                | 11 ++++++
 src/fmt/friendly/printer.rs | 68 +++++++++++++++++++++++++++++++++++--
 2 files changed, 77 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 631d3589..c31f25c7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,16 @@
 # CHANGELOG
 
+0.1.21 (TBD)
+============
+TODO
+
+Enhancements:
+
+* [#192](https://github.com/BurntSushi/jiff/issues/192):
+Add option to the friendly printer for setting the unit when writing a
+zero-length duration.
+
+
 0.1.20 (2025-01-03)
 ===================
 This release inclues a new type, `Pieces`, in the `jiff::fmt::temporal`
diff --git a/src/fmt/friendly/printer.rs b/src/fmt/friendly/printer.rs
index 8a4b4cdd..330ddfc1 100644
--- a/src/fmt/friendly/printer.rs
+++ b/src/fmt/friendly/printer.rs
@@ -462,6 +462,7 @@ pub struct SpanPrinter {
     hms: bool,
     padding: Option<u8>,
     precision: Option<u8>,
+    zero_unit: Unit,
 }
 
 impl SpanPrinter {
@@ -497,6 +498,7 @@ impl SpanPrinter {
             hms: false,
             padding: None,
             precision: None,
+            zero_unit: Unit::Second,
         }
     }
 
@@ -907,6 +909,65 @@ impl SpanPrinter {
         SpanPrinter { precision, ..self }
     }
 
+    /// Sets the unit to use when printing a duration that is zero.
+    ///
+    /// When [`SpanPrinter::fractional`] is set, then this setting is ignored
+    /// and the zero unit corresponds to the fractional unit specified.
+    ///
+    /// This defaults to [`Unit::Second`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::{fmt::friendly::{FractionalUnit, SpanPrinter}, ToSpan, Unit};
+    ///
+    /// // The default just always uses seconds.
+    /// let printer = SpanPrinter::new();
+    /// assert_eq!(printer.span_to_string(&0.years()), "0s");
+    ///
+    /// // We can set our own unit.
+    /// let printer = SpanPrinter::new().zero_unit(Unit::Year);
+    /// assert_eq!(printer.span_to_string(&0.years()), "0y");
+    ///
+    /// // But it's overridden if fractional units are set.
+    /// let printer = SpanPrinter::new()
+    ///     .zero_unit(Unit::Year)
+    ///     .fractional(Some(FractionalUnit::Minute));
+    /// assert_eq!(printer.span_to_string(&0.years()), "0m");
+    ///
+    /// // One use case for this option is if you're rounding
+    /// // spans and want the zero unit to reflect the smallest
+    /// // unit you're using.
+    /// let printer = SpanPrinter::new().zero_unit(Unit::Minute);
+    /// let span = 5.hours().minutes(30).seconds(59);
+    /// let rounded = span.round(Unit::Minute)?;
+    /// assert_eq!(printer.span_to_string(&rounded), "5h 31m");
+    ///
+    /// let span = 5.seconds();
+    /// let rounded = span.round(Unit::Minute)?;
+    /// assert_eq!(printer.span_to_string(&rounded), "0m");
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    ///
+    /// The same applies for `SignedDuration`:
+    ///
+    /// ```
+    /// use jiff::{fmt::friendly::SpanPrinter, SignedDuration, Unit};
+    ///
+    /// // The default just always uses seconds.
+    /// let printer = SpanPrinter::new();
+    /// assert_eq!(printer.duration_to_string(&SignedDuration::ZERO), "0s");
+    ///
+    /// // We can set our own unit.
+    /// let printer = SpanPrinter::new().zero_unit(Unit::Minute);
+    /// assert_eq!(printer.duration_to_string(&SignedDuration::ZERO), "0m");
+    /// ```
+    #[inline]
+    pub const fn zero_unit(self, unit: Unit) -> SpanPrinter {
+        SpanPrinter { zero_unit: unit, ..self }
+    }
+
     /// Format a `Span` into a string using the "friendly" format.
     ///
     /// This is a convenience routine for [`SpanPrinter::print_span`] with a
@@ -1462,8 +1523,11 @@ impl<'p, 'w, W: Write> DesignatorWriter<'p, 'w, W> {
         }
         // If a fractional unit is set, then we should use that unit
         // specifically to express "zero."
-        let unit =
-            self.printer.fractional.map(Unit::from).unwrap_or(Unit::Second);
+        let unit = self
+            .printer
+            .fractional
+            .map(Unit::from)
+            .unwrap_or(self.printer.zero_unit);
         self.wtr.write_int(&self.fmtint, 0)?;
         self.wtr
             .write_str(self.printer.spacing.between_units_and_designators())?;

From 79083ce630580c68c83384e00f41953a337ae16c Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Sat, 4 Jan 2025 12:00:50 -0500
Subject: [PATCH 8/9] changelog: 0.1.21

---
 CHANGELOG.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c31f25c7..d9553c42 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,9 @@
 # CHANGELOG
 
-0.1.21 (TBD)
-============
-TODO
+0.1.21 (2025-01-04)
+===================
+This release includes a new API for setting the unit designator label in a
+friendly formatted duration for zero-length durations.
 
 Enhancements:
 

From 737076ac9ce34235092081b9ba216cafb120e6af Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Sat, 4 Jan 2025 12:00:57 -0500
Subject: [PATCH 9/9] 0.1.21

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 82e80dcf..f4260f26 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "jiff"
-version = "0.1.20"  #:version
+version = "0.1.21"  #:version
 authors = ["Andrew Gallant <jamslam@gmail.com>"]
 license = "Unlicense OR MIT"
 repository = "https://github.com/BurntSushi/jiff"