fix(ci): emit single pre-alloc entry for --fork= release features

`pre_alloc_matrix` returned an empty list whenever `fill-params`
contained `--fork=X` instead of `--until=X`, so the
`generate-pre-alloc` job was skipped for the `benchmark` feature. The
fill jobs then failed with `Pre-allocation hash not found` because no
pre-alloc artifacts were available to download.

Emit a single matrix entry with empty `from_fork`/`until_fork` for
`--fork=` features; the workflow step now conditionally adds
`--from`/`--until` only when the range is populated, since `fill`
rejects those flags alongside `--fork`. One pre-alloc runner generates
groups for the feature's fork, and every fill runner downloads that
single `pre-alloc-groups__<fork>` artifact.

Also gate `pre_alloc_matrix` on `splits >= 2` to match the phase-1
contract: unsplit features handle pre-allocs inline in the fill job.

Author: danceratopz

.github/scripts/generate_build_matrix.py

@@ -76,6 +76,12 @@ def parse_until_fork(fill_params: str) -> str | None:
     return m.group(1) if m else None
 
 
+def parse_fork_arg(fill_params: str) -> str | None:
+    """Extract the ``--fork`` value from fill-params."""
+    m = re.search(r"--fork[=\s]+(\S+)", fill_params)
+    return m.group(1) if m else None
+
+
 def applicable_ranges(fork_ranges: list[dict], until_fork: str) -> list[dict]:
     """
     Return fork ranges whose ``from`` is at or before *until_fork*.
@@ -131,12 +137,31 @@ def pre_alloc_matrix(
     fork_ranges: list[dict],
 ) -> list[dict]:
     """
-    Build the fork-range matrix for pre-alloc generation (phase 1).
+    Build the matrix for pre-alloc generation (phase 1).
 
-    Pre-alloc groups must be generated with complete per-fork coverage,
-    so they are split by fork range rather than by pytest-split groups.
-    Returns an empty list for unsplit features.
+    ``--until=`` features split pre-alloc generation across fork ranges
+    so each range runs in parallel. ``--fork=`` features emit a single
+    entry with empty ``from_fork``/``until_fork``; the feature's own
+    ``--fork=`` already scopes the run, and passing ``--from``/
+    ``--until`` alongside ``--fork`` is rejected by ``fill``.
+
+    Returns an empty list for features without splits or without a
+    usable fork boundary.
     """
+    if feature.get("splits", 0) < 2:
+        return []
+
+    fork_arg = parse_fork_arg(feature["fill-params"])
+    if fork_arg:
+        return [
+            {
+                "feature": name,
+                "label": fork_arg.lower(),
+                "from_fork": "",
+                "until_fork": "",
+            }
+        ]
+
     until = parse_until_fork(feature["fill-params"])
     if not until or not fork_ranges:
         return []

.github/scripts/tests/test_release_scripts.py

@@ -94,8 +94,16 @@ def test_split_feature_with_fork_param(self):
         assert out["combine_labels"] == " ".join(
             str(i) for i in range(1, splits + 1)
         )
-        # --fork features should not generate a pre-alloc matrix.
-        assert json.loads(out["pre_alloc_matrix"]) == []
+        # --fork features emit a single pre-alloc entry with empty fork
+        # range so the workflow step omits --from/--until (which would
+        # otherwise conflict with --fork in fill-params).
+        pa_matrix = json.loads(out["pre_alloc_matrix"])
+        assert len(pa_matrix) == 1
+        assert pa_matrix[0]["feature"] == "benchmark"
+        assert pa_matrix[0]["label"] == "osaka"
+        assert pa_matrix[0]["from_fork"] == ""
+        assert pa_matrix[0]["until_fork"] == ""
+        assert out["pre_alloc_labels"] == "osaka"
 
     def test_feature_only_can_be_requested_explicitly(self):
         """Verify feature_only entries work when named directly."""

.github/workflows/release_fixture_feature.yaml

@@ -92,15 +92,19 @@ jobs:
         with:
           type: ${{ steps.properties.outputs.evm-type }}
 
-      - name: Generate pre-alloc groups (phase 1, fork range)
+      - name: Generate pre-alloc groups (phase 1)
         shell: bash
         run: |
           FEATURE_NAME="${{ needs.setup.outputs.feature_name }}"
+          RANGE_ARGS=""
+          if [ -n "${{ matrix.from_fork }}" ]; then
+            RANGE_ARGS="--from=${{ matrix.from_fork }} --until=${{ matrix.until_fork }}"
+          fi
           EXIT_CODE=0
           if [ "${{ steps.evm-builder.outputs.impl }}" = "eels" ]; then
-            uv run fill -n ${{ steps.evm-builder.outputs.x-dist }} ${{ steps.properties.outputs.fill-params }} --generate-pre-alloc-groups --from=${{ matrix.from_fork }} --until=${{ matrix.until_fork }} --output=fixtures_${FEATURE_NAME} --build-name ${FEATURE_NAME} --no-html -qq || EXIT_CODE=$?
+            uv run fill -n ${{ steps.evm-builder.outputs.x-dist }} ${{ steps.properties.outputs.fill-params }} --generate-pre-alloc-groups $RANGE_ARGS --output=fixtures_${FEATURE_NAME} --build-name ${FEATURE_NAME} --no-html -qq || EXIT_CODE=$?
           else
-            uv run fill -n ${{ steps.evm-builder.outputs.x-dist }} --evm-bin=${{ steps.evm-builder.outputs.evm-bin }} ${{ steps.properties.outputs.fill-params }} --generate-pre-alloc-groups --from=${{ matrix.from_fork }} --until=${{ matrix.until_fork }} --output=fixtures_${FEATURE_NAME} --build-name ${FEATURE_NAME} --no-html -qq || EXIT_CODE=$?
+            uv run fill -n ${{ steps.evm-builder.outputs.x-dist }} --evm-bin=${{ steps.evm-builder.outputs.evm-bin }} ${{ steps.properties.outputs.fill-params }} --generate-pre-alloc-groups $RANGE_ARGS --output=fixtures_${FEATURE_NAME} --build-name ${FEATURE_NAME} --no-html -qq || EXIT_CODE=$?
           fi
           if [ "$EXIT_CODE" -ne 0 ] && [ "$EXIT_CODE" -ne 5 ]; then
             exit "$EXIT_CODE"