Repository navigation
Description
Hi @BenMorel 👋
After finding the plusNanos() bug (#136), I asked Claude Code (Opus 5.5) to audit the parts of brick/date-time we use. This whole issue was written by Claude Code; the audit is its work, not mine. It found 12 bugs and 6 design questions. Every finding was reproduced with a PHP script, checked against java.time, and also exists in 0.9.0.
Status
| # | Finding | Severity | Status |
|---|---|---|---|
| 1 | ZonedDateTime::parse() ignores the offset when a [Region] is present |
medium-high | ✅ #140 |
| 2 | LocalDate::plusPeriod() clamps Feb 29 twice |
medium | ✅ #141 |
| 3 | LocalDateTime::plusDuration() lands on the wrong day when the nano carry crosses midnight |
medium | ✅ #142 |
| 4 | ZonedDateTime with*() and date-based plus*() change the offset in a DST overlap |
medium | ❓ your call |
| 5 | Instant::toDecimal() is wrong for negative epoch seconds with nanos |
medium | 👀 #145 |
| 6 | All parsers accept a trailing "\n" |
low-medium | 👀 #146 |
| 7 | Duration::parse() accepts a trailing lowercase t |
low | 👀 #147 |
| 8 | Region ids containing + can't be parsed |
low | 💬 your go |
| 9 | TimeZone*::parse() docblocks only declare DateTimeParseException |
low | 💬 your go |
| 10 | Some methods produce year ±1000000 instead of throwing | low | 💬 your go |
| 11 | LocalDateRange::parse() turns an invalid end of Feb 29 into Feb 28 |
low | 💬 your go |
| 12 | Month::plus(), DayOfWeek::plus() and Math::floorMod() overflow near PHP_INT_MAX |
low | 💬 your go |
| D1–D6 | Design questions, without a patch | — | ❓ your call |
✅ merged, not released yet · 👀 PR open, ready for review · 💬 clear bug, patch below, waiting for your go · ❓ needs a decision from you
What's left: reviewing #145–#147, and telling me which of 4, 8–12 and D1–D6 you want fixed (one PR per item, like so far, unless you prefer otherwise).
Good to know
- Use the parsed offset in ZonedDateTime::parse() when a region is present #140 goes further than the patch in item 1: as you suggested, it throws when the offset isn't valid for the region. It also fixes the
-07:00[America/Los_Angeles]February fixture. - Fix Instant::toDecimal() for negative epoch seconds with nanos #145, Reject a trailing newline in all parsers #146 and Reject a trailing lowercase t in Duration::parse() #147 each include Add ZonedClock, and remove now() methods and DefaultClock #133's
Install tzdata-legacy in CIcommit. Ubuntu 26.04 runners no longer shipCETorAsia/Rangoon, so PHPUnit fails on every branch based onmainwithout it. The commit is the same in all of them, so it merges cleanly whichever lands first. - Reject a trailing newline in all parsers #146 and Reject a trailing lowercase t in Duration::parse() #147 both change
src/Duration.php, on different lines.
How the audit was run
- Code audited:
main(2cafd91) with Speed upZonedDateTimeconversions, and support years beyond 9999 #135 and Fix LocalDateTime::plusNanos() and minusNanos() within the same second #136 applied. Bugs those two PRs already fix are listed at the end and not repeated. - Files:
LocalDate,LocalTime,LocalDateTime,ZonedDateTime,Instant,Duration,Period,TimeZone*,Year*,Month*,DayOfWeek, the clocks, the parsers,Field/*andUtility/Math. - Method: six reviewers each took one area. Every finding below was reproduced with a PHP script; anything that couldn't be reproduced was dropped. Expected values come from
java.time. Several areas were also diffed against a real JDK 21 (60k generated cases forLocalDate/Period). - Coverage: some areas were also fuzzed (200k random
LocalDateTime/LocalTimeoperations, 300kDuration/Instantoperations checked against exact GMP arithmetic) and matched everywhere except the findings below. - Versions: every finding below also exists in 0.9.0.
Each item has a minimal patch (source only, no tests) to show the size of the change.
Waiting for a decision
4. ❓ ZonedDateTime with*() and date-based plus*() change the offset in a DST overlap (medium)
$first = ZonedDateTime::ofInstant(Instant::of(1729989000), TimeZone::parse('Europe/Zurich')); // 02:30+02:00
$first->withNano(5); // 02:30:00.000000005+01:00: the instant jumps by 1 h (Java keeps +02:00)
$first->plusDays(0); // 02:30+01:00: the instant changes
ZonedDateTime::parse('2024-10-26T02:30+02:00[Europe/Zurich]')->plusDays(1); // 2024-10-27T02:30+01:00, 25 h later (Java: +02:00)Why: every method goes back through of(), which in an overlap uses its documented rule ("offset closest to UTC") and ignores the offset the value already has. Java keeps the current offset whenever it is still valid. The patch adds a private ofLocal() that does that. It is used by all with*(), plusPeriod(), plus{Years,Months,Weeks,Days}() and withTimeZoneSameLocal() methods. Outside overlaps nothing changes. The patch applies cleanly on top of #135.
❓ Separate question: in an overlap, of() picks "closest to UTC". That gives the later offset for Zurich, Sydney, Dublin and Moscow, but the earlier one for New York. Java always uses the earlier one. Changing that would be a documented behaviour change, so I haven't included it.
Patch
--- a/src/ZonedDateTime.php
+++ b/src/ZonedDateTime.php
@@ public static function of(LocalDateTime $dateTime, TimeZone $timeZone): ZonedDateTime
return new ZonedDateTime($dateTime, $timeZoneOffset, $timeZone, $instant);
}
+ /**
+ * Creates a ZonedDateTime from a local date-time, keeping the preferred offset if it is valid (overlap).
+ */
+ private static function ofLocal(LocalDateTime $dateTime, TimeZone $timeZone, TimeZoneOffset $preferredOffset): ZonedDateTime
+ {
+ $zonedDateTime = ZonedDateTime::of($dateTime, $timeZone);
+
+ if ($zonedDateTime->timeZoneOffset->isEqualTo($preferredOffset)) {
+ return $zonedDateTime;
+ }
+
+ $instant = ZonedDateTime::of($dateTime, $preferredOffset)->instant;
+
+ if ($timeZone->getOffset($instant) === $preferredOffset->getTotalSeconds()) {
+ return new ZonedDateTime($dateTime, $preferredOffset, $timeZone, $instant);
+ }
+
+ return $zonedDateTime;
+ }
+
@@ public function withDate(LocalDate $date): ZonedDateTime
- return ZonedDateTime::of($this->localDateTime->withDate($date), $this->timeZone);
+ return ZonedDateTime::ofLocal($this->localDateTime->withDate($date), $this->timeZone, $this->timeZoneOffset);
(same one-line change in withTime, withYear, withMonth, withDay, withHour, withMinute, withSecond, withNano,
plusPeriod, plusYears, plusMonths, plusWeeks, plusDays)
@@ public function withTimeZoneSameLocal(TimeZone $timeZone): ZonedDateTime
- return ZonedDateTime::of($this->localDateTime, $timeZone);
+ return ZonedDateTime::ofLocal($this->localDateTime, $timeZone, $this->timeZoneOffset);8. Region ids containing + can't be parsed (low)
TimeZoneRegion::of('Etc/GMT+5'); // works
TimeZone::parse('Etc/GMT+5'); // DateTimeParseException
// so the library can't parse its own output:
ZonedDateTime::parse((string) ZonedDateTime::of(LocalDateTime::parse('2020-01-01T00:00'), TimeZoneRegion::of('Etc/GMT+5'))); // throws
ZonedDateTime::fromNativeDateTime(new DateTime('2024-06-01', new DateTimeZone('Etc/GMT+1'))); // throwsThere are 14 such ids, Etc/GMT+0 to Etc/GMT+12 and GMT+0, all in DateTimeZone::ALL_WITH_BC. Java's pattern is [A-Za-z][A-Za-z0-9~/._+-]+. The patch only adds +, because also allowing . changes the exception type expected by an existing test (Europe.London).
Patch
--- a/src/Field/TimeZoneRegion.php
+++ b/src/Field/TimeZoneRegion.php
- public const PATTERN = '[A-Za-z0-9\/_\-]+';
+ public const PATTERN = '[A-Za-z0-9\/_+\-]+';9. TimeZone*::parse() docblocks only declare DateTimeParseException (low)
TimeZone::parse('+19:00'), TimeZoneOffset::parse('+01:60') and TimeZoneRegion::parse('Europe/Nowhere') all throw a plain DateTimeException, which a catch (DateTimeParseException) misses. The other value classes already document DateTimeException. Java wraps these errors in DateTimeParseException; the patch only documents the current behaviour.
Patch
--- a/src/TimeZone.php
+++ b/src/TimeZone.php
- * @throws DateTimeParseException
+ * @throws DateTimeException If the text cannot be parsed, or the offset or region is not valid.
--- a/src/TimeZoneOffset.php
+++ b/src/TimeZoneOffset.php
- * @throws DateTimeParseException
+ * @throws DateTimeException If the text cannot be parsed, or the result is not valid.
--- a/src/TimeZoneRegion.php
+++ b/src/TimeZoneRegion.php
- * @throws DateTimeParseException
+ * @throws DateTimeException If the text cannot be parsed, or the result is not valid.10. Some methods produce year 1000000 or -1000000 instead of throwing (low)
LocalDate::max()->plusDays(1); // 1000000-01-01 (plusDays(2) throws correctly)
LocalDate::of(999999, 12, 1)->plusMonths(1); // 1000000-01-01
LocalDate::min()->minusMonths(1); // -1000000-12-01
YearMonth::of(999999, 12)->plusMonths(1); // 1000000-01
YearWeek::of(999999, 52)->withWeek(53); // 1000000-W01
LocalDate::fromNativeDateTime((new DateTime())->setDate(1000000, 1, 1)); // 1000000-01-01The resulting objects break the class invariant: their string form can't be parsed back, and some later calls throw. LocalDateTime::max()->plusSeconds(1) and similar calls go through the plusDays(1) fast path, so they are affected too.
Patch
--- a/src/LocalDate.php
+++ b/src/LocalDate.php
@@ public static function fromNativeDateTime(DateTimeInterface $dateTime): LocalDate
$day = (int) $dateTime->format('j');
+ Field\Year::check($year);
+
return new LocalDate($year, $month, $day);
@@ public function plusMonths(int $months): LocalDate
$year = $this->year + $yearDiff;
+ Field\Year::check($year);
+
return $this->resolvePreviousValid($year, $month, $this->day);
@@ public function plusDays(int $days): LocalDate
if ($this->day >= 28 && $this->day === $this->getLengthOfMonth()) {
+ if ($this->month === 12) {
+ Field\Year::check($this->year + 1);
+ }
+
return new self($this->year + intdiv($this->month, 12), ($this->month % 12) + 1, 1);
--- a/src/YearMonth.php
+++ b/src/YearMonth.php
@@ public function plusMonths(int $months): YearMonth
$year = $this->year + $yearDiff;
+ Field\Year::check($year);
+
return new YearMonth($year, $month);
--- a/src/YearWeek.php
+++ b/src/YearWeek.php
@@ public function withWeek(int $week): YearWeek
$year++;
$week = 1;
+
+ Field\Year::check($year);
}11. LocalDateRange::parse() silently turns an invalid end of Feb 29 into Feb 28 (low)
LocalDateRange::parse('2015-01-01/02-29'); // 2015-01-01/2015-02-28 (expected DateTimeException, like LocalDate::parse('2015-02-29'))MonthDay::atYear() clamps on purpose, which is wrong for parsing.
Patch
--- a/src/LocalDateRange.php
+++ b/src/LocalDateRange.php
- $endDate = MonthDay::from($result)->atYear($startDate->getYear());
+ $endDate = LocalDate::of($startDate->getYear(), (int) $result->getField(Field\MonthOfYear::NAME), (int) $result->getField(Field\DayOfMonth::NAME));12. Month::plus(), DayOfWeek::plus() and Math::floorMod() overflow near PHP_INT_MAX (low)
Month::FEBRUARY->plus(PHP_INT_MAX); // MAY, with a "float not representable" warning (expected SEPTEMBER)
DayOfWeek::TUESDAY->plus(PHP_INT_MAX); // SUNDAY (expected TUESDAY)
Math::floorMod(1, PHP_INT_MAX); // -1 (expected 1)Patch
--- a/src/Month.php
+++ b/src/Month.php
- return Month::from((((($this->value - 1 + $months) % 12) + 12) % 12) + 1);
+ return Month::from((((($this->value - 1 + $months % 12) % 12) + 12) % 12) + 1);
--- a/src/DayOfWeek.php
+++ b/src/DayOfWeek.php
- return DayOfWeek::from((((($this->value - 1 + $days) % 7) + 7) % 7) + 1);
+ return DayOfWeek::from((((($this->value - 1 + $days % 7) % 7) + 7) % 7) + 1);
--- a/src/Utility/Math.php
+++ b/src/Utility/Math.php
- return (($a % $b) + $b) % $b;
+ $mod = $a % $b;
+
+ return ($mod !== 0 && ($mod ^ $b) < 0) ? $mod + $b : $mod;❓ Design questions
-
D1.
TimeZoneRegion::of()accepts ids that aren't regions.TimeZone::parse('CET')gives a fixed-offset+01:00[CET]with no DST; IANA's CET has DST, so July should be+02:00. MET, EET and WET behave the same way.TimeZone::parse('CEST')is accepted as a fixed+02:00"region".TimeZoneRegion::of('GMT+1')returns a region whose id is+01:00, and itsZonedDateTimeprints…+01:00[+01:00], which can't be parsed back.TimeZone::parse('europe/zurich')keeps that casing, soisEqualTo(Europe/Zurich)is false.- Java rejects all of these. Possible fixes: reject
DateTimeZones whose type isn't 3, and normalise the casing throughDateTimeZone::listIdentifiers().
-
D2.
Instant::min()/max()are documented as "far past"/"far future" values but can't be printed, JSON-encoded or converted to aZonedDateTime.PHP_INT_MIN/MAXseconds fall outsideLocalDate's ±999,999-year range. Java'sInstant.MIN/MAXstay within the range of itsLocalDateTime. You could clamp them to that range, or document that they are only meant for comparisons. -
D3. Integer overflow raises
TypeErrorinstead ofDateTimeException/ArithmeticErrorin many places. Plain+,*and unary-turn into a float, which strict types then reject. Examples:Instant::max()->plusSeconds(1),Duration::ofSeconds(PHP_INT_MIN)->negated()and(string) Duration::ofSeconds(PHP_INT_MIN)LocalDate::ofEpochDay(PHP_INT_MAX),Year::of(2000)->plus(PHP_INT_MAX)andPeriod::ofDays(PHP_INT_MAX)->multipliedBy(2)LocalTime::of(0, 0)->minusHours(PHP_INT_MIN)LocalDateTime::of(2000, 1, 1, 0, 0, 0, 1)->plusNanos(PHP_INT_MAX), which is a valid result in JavaDuration::ofMillis(500)->multipliedBy(20_000_000_000), which would fit if computed differently
Math::addExact/multiplyExactexist but are rarely used. Is this worth handling consistently? -
D4.
Duration::parse()andPeriod::parse()silently cap numbers that are too large.(int)cuts the value down toPHP_INT_MAX:PT9223372036854775808SandP99999999999999999999Yare accepted. Java throws. -
D5. Small differences in what the parsers accept compared with Java's ISO parsers:
LocalDate::parse('02014-12-31')and'-0000-01-01'are accepted.LocalDateTime::parse('2014-12-31t10:15')is rejected, while a lowercasezis accepted.
-
D6.
Period::fromNativeDateInterval()silently drops relative parts.DateInterval::createFromDateString('last day of next month')givesP1M, and'next monday'givesP0D.
Done or in review
1. ZonedDateTime::parse() ignores the offset when a [Region] is present (medium-high) ✅ #140
$z = ZonedDateTime::ofInstant(Instant::of(1729989000), TimeZone::parse('Europe/Zurich'));
(string) $z; // 2024-10-27T02:30:00+02:00[Europe/Zurich] (first 02:30 of the DST fall-back)
ZonedDateTime::parse((string) $z)->isEqualTo($z); // false: parses to +01:00, one hour later
ZonedDateTime::parse('2024-06-01T12:00Z[Europe/Zurich]'); // 12:00+02:00 (Java: 14:00+02:00, same instant as the input)
ZonedDateTime::parse('2024-06-01T12:00+05:00[Europe/Zurich]'); // 12:00+02:00 (Java: 09:00+02:00)Why: from() parses the offset, throws it away, and resolves the local date-time against the region again. As a result, toString() → parse() doesn't round-trip in the fall-back hour, and a string such as …Z[Europe/Zurich] (the format JS Temporal emits) gives the wrong instant.
Fix: do what Java does: compute the instant from the local date-time and the offset, then convert it to the region.
Consequence for the test suite: ZonedDateTimeTest::testPlusPeriod/testMinusPeriod data set #11 fail. Their input, 2000-02-16T12:34:56.123456789-07:00[America/Los_Angeles], uses an offset Los Angeles never has in February. It only passed because the offset was ignored. With the fix it reads as 11:34:56-08:00, which is what Java gives, so that fixture's offset should become -08:00.
Patch
--- a/src/ZonedDateTime.php
+++ b/src/ZonedDateTime.php
@@ public static function from(DateTimeParseResult $result): ZonedDateTime
$timeZoneOffset = TimeZoneOffset::from($result);
if ($result->hasField(Field\TimeZoneRegion::NAME)) {
- $timeZone = TimeZoneRegion::from($result);
- } else {
- $timeZone = $timeZoneOffset;
+ return ZonedDateTime::ofInstant(
+ ZonedDateTime::of($localDateTime, $timeZoneOffset)->getInstant(),
+ TimeZoneRegion::from($result),
+ );
}
- return ZonedDateTime::of(
- $localDateTime,
- $timeZone,
- );
+ return ZonedDateTime::of($localDateTime, $timeZoneOffset);
}2. LocalDate::plusPeriod() clamps Feb 29 twice (medium) ✅ #141
$d = LocalDate::of(2020, 2, 29);
$d->plusPeriod(Period::of(1, 1, 0)); // 2021-03-28 (Java: 2021-03-29)
$d->plusPeriod(Period::ofMonths(13)); // 2021-03-29
$d->plusPeriod(Period::ofMonths(18)->normalized()); // 2021-08-28, but P18M gives 2021-08-29
$d->plusPeriod($d->until(LocalDate::of(2021, 3, 29))); // 2021-03-28: until() and plusPeriod() don't round-trip
LocalDate::of(999995, 2, 26)->plusPeriod(Period::of(5, -29, 5)); // throws "Invalid year: 1000000" (Java: 999997-10-01)Why: plusYears() and then plusMonths() each clamp Feb 29. An intermediate year can also be out of range even when the final date is valid. Java adds toTotalMonths() in one step. LocalDateTime::plusPeriod() and ZonedDateTime::plusPeriod() inherit the problem.
Patch
--- a/src/LocalDate.php
+++ b/src/LocalDate.php
@@ public function plusPeriod(Period $period): LocalDate
return $this
- ->plusYears($period->getYears())
- ->plusMonths($period->getMonths())
+ ->plusMonths($period->getYears() * 12 + $period->getMonths())
->plusDays($period->getDays());3. LocalDateTime::plusDuration() / minusDuration() land on the wrong day when the nano carry crosses midnight (medium) ✅ #142
LocalDateTime::of(2000, 1, 1, 0, 0, 0, 500_000_000)->minusDuration(Duration::ofMillis(400));
// 1999-12-31T00:00:00.1 (expected 2000-01-01T00:00:00.1)
LocalDateTime::of(2000, 1, 1, 23, 59, 59, 500_000_000)->plusDuration(Duration::ofMillis(600));
// 2000-01-01T00:00:00.1 (expected 2000-01-02T00:00:00.1)Why: the day shift ignores the carry from nano + duration nanos ≥ 1e9, while LocalTime::plusDuration() does apply it. A negative fractional duration is stored as (-1 s, +n ns), so subtracting a fraction early in the day also hits this. It only happens when both the date-time and the duration have a fractional second.
Patch
--- a/src/LocalDateTime.php
+++ b/src/LocalDateTime.php
@@ public function plusDuration(Duration $duration): LocalDateTime
- $days = Math::floorDiv($this->time->toSecondOfDay() + $duration->getSeconds(), LocalTime::SECONDS_PER_DAY);
+ $seconds = $this->time->toSecondOfDay() + $duration->getSeconds()
+ + intdiv($this->time->getNano() + $duration->getNanos(), LocalTime::NANOS_PER_SECOND);
+
+ $days = Math::floorDiv($seconds, LocalTime::SECONDS_PER_DAY);5. Instant::toDecimal() is wrong for negative epoch seconds with nanos (medium) 👀 #145
Instant::of(-1, 500_000_000)->toDecimal(); // "-1.5" (expected "-0.5")
Instant::of(0, -1)->toDecimal(); // "-1.999999999" (expected "-0.000000001")
Instant::of(-2, 250_000_000)->toDecimal(); // "-2.25" (expected "-1.75")Why: it concatenates the floored second with the positive nano adjustment. toISOString() handles the same values correctly.
Patch
--- a/src/Instant.php
+++ b/src/Instant.php
@@ public function toDecimal(): string
- $result = (string) $this->epochSecond;
-
- if ($this->nano !== 0) {
- $nano = (string) $this->nano;
- $nano = str_pad($nano, 9, '0', STR_PAD_LEFT);
- $nano = rtrim($nano, '0');
-
- $result .= '.' . $nano;
+ if ($this->nano === 0) {
+ return (string) $this->epochSecond;
}
- return $result;
+ if ($this->epochSecond < 0) {
+ $result = '-' . -($this->epochSecond + 1);
+ $nano = (string) (LocalTime::NANOS_PER_SECOND - $this->nano);
+ } else {
+ $result = (string) $this->epochSecond;
+ $nano = (string) $this->nano;
+ }
+
+ return $result . '.' . rtrim(str_pad($nano, 9, '0', STR_PAD_LEFT), '0');6. All ISO parsers, Duration::parse() and Period::parse() accept a trailing "\n" (low-medium) 👀 #146
LocalDate::parse("2014-12-31\n"); // 2014-12-31 (same for LocalTime, LocalDateTime, ZonedDateTime, YearMonth, Year, TimeZoneRegion, …)
Period::parse("P1D\n"); // P1D
Duration::parse("PT1S\n"); // PT1SWhy: in PCRE, $ without the D modifier also matches before a final newline. Code that validates with parse() and then stores the raw string keeps the newline.
Patch
--- a/src/Parser/PatternParser.php
+++ b/src/Parser/PatternParser.php
- $pattern = '/^' . $this->pattern . '$/';
+ $pattern = '/^' . $this->pattern . '$/D';
--- a/src/Period.php
+++ b/src/Period.php
- '()$/i';
+ '()$/iD';
--- a/src/Duration.php
+++ b/src/Duration.php
- '()$/i';
+ '()$/iD';7. Duration::parse() accepts a trailing lowercase t (low) 👀 #147
Duration::parse('P1DT'); // DateTimeParseException (correct)
Duration::parse('P1Dt'); // PT24H (expected DateTimeParseException)Why: the pattern is case-insensitive, but the check that a T must be followed by a time field compares against 'T' exactly.
Patch
--- a/src/Duration.php
+++ b/src/Duration.php
- if ($days === '' || $t === 'T') {
+ if ($days === '' || $t !== '') {Already fixed by #135 / #136 (before this audit)
- Speed up
ZonedDateTimeconversions, and support years beyond 9999 #135:- Years ≥ 10000 in
ZonedDateTime::of()/parse(),LocalDateTime::atTimeZone()andLocal*::toNativeDateTime(): wrong year without any error (LocalDateTime::max()→ 1999-12-31) or a nativeDateMalformedStringException. - Negative years in
toNativeDateTime(). ZonedDateTime::toNativeDateTime()giving the wrong instant in a DST overlap.- Fuzzing found no regressions: 60k random cases gave identical results to
mainoutside the intended fixes, along with a DST sweep for Zurich, New York and Lord Howe and every year from -999999 to 999999.
- Years ≥ 10000 in
- Fix LocalDateTime::plusNanos() and minusNanos() within the same second #136:
LocalDateTime::plusNanos()/minusNanos()within the same second.
🤖 Generated with Claude Code
Activity
BenMorel commentedon Oct 9, 2026
Hi @gnutix, thank you for this analysis. I'll start with the first three.
1.
ZonedDateTime::parse()ignores the offset when a[Region]is presentThis is a valid concern, and I think the proposed patch addresses it. I would go farther though, and throw an exception if the resulting offset is different from the one given:
2.
LocalDate::plusPeriod()clamps Feb 29 twiceI guess it makes sense to group year and month to avoid this issue. Let's do it!
3.
LocalDateTime::plusDuration()/minusDuration()land on the wrong day when the nano carry crosses midnightGood find. Let's fix it!
gnutix commentedon Oct 10, 2026
@BenMorel 3 PRs created 👍 Don't hesitate to ask if you'd like me to open PRs for others in that list, or close the issue whenever you think we're good.
BenMorel commentedon Oct 10, 2026
@gnutix You can follow with 5, 6, 7!
gnutix commentedon Nov 7, 2026
@BenMorel 5-6-7 done. Sorry I didn't see your comment earlier. Let me know if/when you want the rest!