Let a branch alias be ahead of the tags

The check called an alias ahead of the newest tag an error, which is the state
every release passes through: the alias is bumped in the commit before the tag
exists, so the check was red for exactly as long as a release takes.

Behind is the defect — that is a development branch Composer places in a range
nobody is asking for. Ahead is dev-main saying what is coming.

Compared as numbers rather than as strings, so 0.9 does not come after 0.13.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012AppuDfzu2xSefw86WcUhJ

Author: Radoslaw Ziemniewicz

src/Checks/Manifest.php

@@ -114,20 +114,37 @@ private function alias(Package $package, array $extra): array
             return [];
         }
 
-        $line = implode('.', array_slice(explode('.', ltrim($tag, 'vV')), 0, 2));
-        $expected = "{$line}.x-dev";
+        $line = array_slice(explode('.', ltrim($tag, 'vV')), 0, 2);
+        $expected = implode('.', $line) . '.x-dev';
 
-        if ($alias === $expected) {
+        // The alias may be ahead of the tags: `dev-main` is the release being prepared, and
+        // the alias is bumped in the commit before the tag exists. Behind is the defect — that
+        // is a development branch Composer places in a range nobody is asking for.
+        if (self::asNumbers($alias) >= self::asNumbers($expected)) {
             return [];
         }
 
         return [Finding::failed(
             $this->name(),
             "The branch alias is `{$alias}`, and the newest tag is `{$tag}`.",
-            "Composer reads the alias to decide what `dev-main` is, so it wants `{$expected}`."
+            "Composer reads the alias to decide what `dev-main` is, so it wants `{$expected}` "
+            . 'or the line being prepared.'
         )];
     }
 
+    /**
+     * A `0.13.x-dev` read as something two numbers can be compared by, so `0.9` does not come
+     * after `0.13` the way it does alphabetically.
+     *
+     * @return array{0: int, 1: int}
+     */
+    private static function asNumbers(string $alias): array
+    {
+        $parts = explode('.', $alias);
+
+        return [(int) $parts[0], (int) ($parts[1] ?? 0)];
+    }
+
     /**
      * The newest tag here, by version rather than by name — `v0.9.1` sorts after `v0.13.0`
      * alphabetically and before it in every way that matters.

tests/Unit/TestManifestAndBadges.php

@@ -122,4 +122,36 @@ public function aBranchAliasWhichDoesNotMatchTheTagsIsFound()
 
         $this->assertEqual->equal(0, $this->failures($this->manifest()->run($here)));
     }
+
+    /**
+     * An alias ahead of the tags is the release being prepared: it is bumped in the commit
+     * before the tag exists, and a check which called that an error would be red for the whole
+     * of every release. Behind is the defect.
+     */
+    public function anAliasAheadOfTheTagsIsTheOneBeingPrepared()
+    {
+        $ahead = [self::class, 'aheadAndBehind'];
+
+        $this->assertEqual->equal([true, false], $ahead());
+    }
+
+    /**
+     * @return array{0: bool, 1: bool}
+     */
+    public static function aheadAndBehind(): array
+    {
+        $manifest = new Manifest('https://quillstack.org/packages/{name}', [], true, []);
+        $method = new \ReflectionMethod($manifest, 'asNumbers');
+
+        /** @var array{0: int, 1: int} $prepared */
+        $prepared = $method->invoke(null, '0.7.x-dev');
+        /** @var array{0: int, 1: int} $tagged */
+        $tagged = $method->invoke(null, '0.6.x-dev');
+        /** @var array{0: int, 1: int} $stale */
+        $stale = $method->invoke(null, '0.9.x-dev');
+        /** @var array{0: int, 1: int} $line */
+        $line = $method->invoke(null, '0.13.x-dev');
+
+        return [$prepared >= $tagged, $stale >= $line];
+    }
 }