Skip to content

Correctness audit by Claude Code (Opus 5.5): which findings should be fixed? #137

Open

Description

@gnutix

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

How the audit was run
  • Code audited: main (2cafd91) with Speed up ZonedDateTime conversions, 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/* and Utility/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 for LocalDate/Period).
  • Coverage: some areas were also fuzzed (200k random LocalDateTime/LocalTime operations, 300k Duration/Instant operations 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')));                                // throws

There 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-01

The 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 its ZonedDateTime prints …+01:00[+01:00], which can't be parsed back.
    • TimeZone::parse('europe/zurich') keeps that casing, so isEqualTo(Europe/Zurich) is false.
    • Java rejects all of these. Possible fixes: reject DateTimeZones whose type isn't 3, and normalise the casing through DateTimeZone::listIdentifiers().
  • D2. Instant::min()/max() are documented as "far past"/"far future" values but can't be printed, JSON-encoded or converted to a ZonedDateTime. PHP_INT_MIN/MAX seconds fall outside LocalDate's ±999,999-year range. Java's Instant.MIN/MAX stay within the range of its LocalDateTime. You could clamp them to that range, or document that they are only meant for comparisons.

  • D3. Integer overflow raises TypeError instead of DateTimeException/ArithmeticError in 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) and Period::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 Java
    • Duration::ofMillis(500)->multipliedBy(20_000_000_000), which would fit if computed differently

    Math::addExact/multiplyExact exist but are rarely used. Is this worth handling consistently?

  • D4. Duration::parse() and Period::parse() silently cap numbers that are too large. (int) cuts the value down to PHP_INT_MAX: PT9223372036854775808S and P99999999999999999999Y are 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 lowercase z is accepted.
  • D6. Period::fromNativeDateInterval() silently drops relative parts. DateInterval::createFromDateString('last day of next month') gives P1M, and 'next monday' gives P0D.


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");             // PT1S

Why: 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 ZonedDateTime conversions, and support years beyond 9999 #135:
    • Years ≥ 10000 in ZonedDateTime::of()/parse(), LocalDateTime::atTimeZone() and Local*::toNativeDateTime(): wrong year without any error (LocalDateTime::max() → 1999-12-31) or a native DateMalformedStringException.
    • 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 main outside the intended fixes, along with a DST sweep for Zurich, New York and Lord Howe and every year from -999999 to 999999.
  • Fix LocalDateTime::plusNanos() and minusNanos() within the same second #136: LocalDateTime::plusNanos()/minusNanos() within the same second.

🤖 Generated with Claude Code

Activity

  1. BenMorel commented on Oct 9, 2026

    @BenMorel
    Member

    Hi @gnutix, thank you for this analysis. I'll start with the first three.

    1. ZonedDateTime::parse() ignores the offset when a [Region] is present

    This 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:

      if ($result->hasField(Field\TimeZoneRegion::NAME)) {
          $zonedDateTime = ZonedDateTime::ofInstant(
              ZonedDateTime::of($localDateTime, $timeZoneOffset)->getInstant(),
              TimeZoneRegion::from($result),
          );
    
          if (! $zonedDateTime->getTimeZoneOffset()->isEqualTo($timeZoneOffset)) {
              throw new DateTimeException(sprintf(
                  'The offset %s is not valid for %s in %s.',
                  $timeZoneOffset,
                  $localDateTime,
                  $zonedDateTime->getTimeZone(),
              ));
          }
    
          return $zonedDateTime;
      }

    2. LocalDate::plusPeriod() clamps Feb 29 twice

    I 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 midnight

    Good find. Let's fix it!

  2. gnutix commented on Oct 10, 2026

    @gnutix
    ContributorAuthor

    @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.

  3. BenMorel commented on Oct 10, 2026

    @BenMorel
    Member

    @gnutix You can follow with 5, 6, 7!

  4. gnutix commented on Nov 7, 2026

    @gnutix
    ContributorAuthor

    @BenMorel 5-6-7 done. Sorry I didn't see your comment earlier. Let me know if/when you want the rest!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions