refactor(all): update lang from 'shared pre-alloc' to 'pre-allocation groups' 1/2

Terminology:
- 'shared pre-allocation' → 'pre-allocation groups'
- 'shared pre-state' → 'pre-allocation groups'

Flags:
-  `--generate-shared-pre` -> `--generate-grouped-pre-allocs`
-  `--use-shared-pre` -> `--use-grouped-pre-allocs`

Method names updated:
- `update_shared_pre_state` → `update_pre_alloc_groups`
- `compute_shared_pre_alloc_hash` → `compute_pre_alloc_group_hash`
- `shared_pre_alloc_folder_path` → `grouped_pre_allocs_folder_path`

Author: danceratopz

docs/running_tests/test_formats/blockchain_test_engine_x.md

@@ -50,15 +50,15 @@ Each file in the `pre_alloc` folder corresponds to a pre-allocation hash to shar
 
 For each [`BlockchainTestEngineXFixture`](#BlockchainTestEngineXFixture) test object in the JSON fixture file, perform the following steps:
 
-1. **Load Shared Pre-Allocation**:
+1. **Load Pre-Allocation Group**:
    - Read the appropriate file from the `pre_alloc` folder in the same directory
-   - Locate the shared state group using [`preHash`](#-prehash-string)
-   - Extract the `pre` allocation and `environment` from the shared group
+   - Locate the pre-allocation group using [`preHash`](#-prehash-string)
+   - Extract the `pre` allocation and `environment` from the group
 
 2. **Initialize Client**:
    - Use [`network`](#-network-fork) to configure the execution fork schedule
-   - Use the shared `pre` allocation as the starting state
-   - Use the shared `environment` as the execution context
+   - Use the pre-allocation group's `pre` allocation as the starting state
+   - Use the pre-allocation group's `environment` as the execution context
    - Use [`genesisBlockHeader`](#-genesisblockheader-fixtureheader) as the genesis block header
 
 3. **Execute Engine API Sequence**:

src/cli/pytest_commands/fill.py

@@ -23,19 +23,19 @@ def __init__(self):
 
     def create_executions(self, pytest_args: List[str]) -> List[PytestExecution]:
         """
-        Create execution plan that supports two-phase shared pre-state generation.
+        Create execution plan that supports two-phase pre-allocation group generation.
 
         Returns single execution for normal filling, or two-phase execution
-        when --gen-shared-pre is specified.
+        when --generate-grouped-pre-allocs is specified.
         """
         processed_args = self.process_arguments(pytest_args)
 
         # Check if we need two-phase execution
-        if "--generate-shared-pre" in processed_args:
+        if "--generate-grouped-pre-allocs" in processed_args:
             return self._create_two_phase_executions(processed_args)
-        elif "--use-shared-pre" in processed_args:
-            # Only phase 2: using existing shared pre-allocation state
-            return self._create_single_phase_with_shared_alloc(processed_args)
+        elif "--use-grouped-pre-allocs" in processed_args:
+            # Only phase 2: using existing pre-allocation groups
+            return self._create_single_phase_with_grouped_pre_allocs(processed_args)
         else:
             # Normal single-phase execution
             return [
@@ -46,8 +46,8 @@ def create_executions(self, pytest_args: List[str]) -> List[PytestExecution]:
             ]
 
     def _create_two_phase_executions(self, args: List[str]) -> List[PytestExecution]:
-        """Create two-phase execution: shared allocation generation + fixture filling."""
-        # Phase 1: Shared allocation generation (clean and minimal output)
+        """Create two-phase execution: pre-allocation group generation + fixture filling."""
+        # Phase 1: Pre-allocation group generation (clean and minimal output)
         phase1_args = self._create_phase1_args(args)
 
         # Phase 2: Main fixture generation (full user options)
@@ -57,7 +57,7 @@ def _create_two_phase_executions(self, args: List[str]) -> List[PytestExecution]
             PytestExecution(
                 config_file=self.config_file,
                 args=phase1_args,
-                description="generating shared pre-allocation state",
+                description="generating pre-allocation groups",
             ),
             PytestExecution(
                 config_file=self.config_file,
@@ -66,8 +66,10 @@ def _create_two_phase_executions(self, args: List[str]) -> List[PytestExecution]
             ),
         ]
 
-    def _create_single_phase_with_shared_alloc(self, args: List[str]) -> List[PytestExecution]:
-        """Create single execution using existing shared pre-allocation state."""
+    def _create_single_phase_with_grouped_pre_allocs(
+        self, args: List[str]
+    ) -> List[PytestExecution]:
+        """Create single execution using existing pre-allocation groups."""
         return [
             PytestExecution(
                 config_file=self.config_file,
@@ -76,24 +78,24 @@ def _create_single_phase_with_shared_alloc(self, args: List[str]) -> List[Pytest
         ]
 
     def _create_phase1_args(self, args: List[str]) -> List[str]:
-        """Create arguments for phase 1 (shared allocation generation)."""
+        """Create arguments for phase 1 (pre-allocation group generation)."""
         # Start with all args, then remove what we don't want for phase 1
         filtered_args = self._remove_unwanted_phase1_args(args)
 
         # Add required phase 1 flags (with quiet output by default)
         phase1_args = [
-            "--generate-shared-pre",
+            "--generate-grouped-pre-allocs",
             "-qq",  # Quiet pytest output by default (user -v/-vv/-vvv can override)
         ] + filtered_args
 
         return phase1_args
 
     def _create_phase2_args(self, args: List[str]) -> List[str]:
         """Create arguments for phase 2 (fixture filling)."""
-        # Remove --generate-shared-pre and --clean, then add --use-shared-pre
-        phase2_args = self._remove_generate_shared_pre_flag(args)
+        # Remove --generate-grouped-pre-allocs and --clean, then add --use-grouped-pre-allocs
+        phase2_args = self._remove_generate_grouped_pre_allocs_flag(args)
         phase2_args = self._remove_clean_flag(phase2_args)
-        phase2_args = self._add_use_shared_pre_flag(phase2_args)
+        phase2_args = self._add_use_grouped_pre_allocs_flag(phase2_args)
         return phase2_args
 
     def _remove_unwanted_phase1_args(self, args: List[str]) -> List[str]:
@@ -106,9 +108,9 @@ def _remove_unwanted_phase1_args(self, args: List[str]) -> List[str]:
             "--quiet",
             "-qq",
             "--tb",
-            # Shared allocation flags (we'll add our own)
-            "--generate-shared-pre",
-            "--use-shared-pre",
+            # Pre-allocation group flags (we'll add our own)
+            "--generate-grouped-pre-allocs",
+            "--use-grouped-pre-allocs",
         }
 
         filtered_args = []
@@ -132,17 +134,17 @@ def _remove_unwanted_phase1_args(self, args: List[str]) -> List[str]:
 
         return filtered_args
 
-    def _remove_generate_shared_pre_flag(self, args: List[str]) -> List[str]:
-        """Remove --generate-shared-pre flag from argument list."""
-        return [arg for arg in args if arg != "--generate-shared-pre"]
+    def _remove_generate_grouped_pre_allocs_flag(self, args: List[str]) -> List[str]:
+        """Remove --generate-grouped-pre-allocs flag from argument list."""
+        return [arg for arg in args if arg != "--generate-grouped-pre-allocs"]
 
     def _remove_clean_flag(self, args: List[str]) -> List[str]:
         """Remove --clean flag from argument list."""
         return [arg for arg in args if arg != "--clean"]
 
-    def _add_use_shared_pre_flag(self, args: List[str]) -> List[str]:
-        """Add --use-shared-pre flag to argument list."""
-        return args + ["--use-shared-pre"]
+    def _add_use_grouped_pre_allocs_flag(self, args: List[str]) -> List[str]:
+        """Add --use-grouped-pre-allocs flag to argument list."""
+        return args + ["--use-grouped-pre-allocs"]
 
 
 class PhilCommand(FillCommand):

src/cli/show_pre_alloc_group_stats.py

@@ -1,4 +1,4 @@
-"""Script to display statistics about shared pre-allocation groups."""
+"""Script to display statistics about pre-allocation groups."""
 
 from collections import defaultdict
 from pathlib import Path
@@ -393,7 +393,7 @@ def display_stats(stats: Dict, console: Console, verbose: int = 0):
         console.print("\n[bold yellow]Test Functions Split Across Multiple Groups[/bold yellow]")
         console.print(
             "[dim]These test functions create multiple size-1 groups (due to different "
-            "forks/parameters), preventing shared pre-allocation optimization:[/dim]",
+            "forks/parameters), preventing pre-allocation group optimization:[/dim]",
             highlight=False,
         )
 
@@ -462,19 +462,19 @@ def display_stats(stats: Dict, console: Console, verbose: int = 0):
 )
 def main(pre_alloc_folder: Path, verbose: int):
     """
-    Display statistics about shared pre-allocation groups.
+    Display statistics about pre-allocation groups.
 
     This script analyzes a pre_alloc folder generated by the test framework's
-    shared pre-allocation optimization feature and displays:
+    pre-allocation group optimization feature and displays:
 
     - Total number of groups, tests, and accounts
     - Number of tests and accounts per group (tabulated)
     - Number of groups and tests per fork (tabulated)
     - Number of groups and tests per test module (tabulated)
 
     The pre_alloc file is generated when running tests with the
-    --generate-shared-pre and --use-shared-pre flags to optimize
-    test execution by sharing pre-allocation state across tests.
+    --generate-grouped-pre-allocs and --use-grouped-pre-allocs flags to optimize
+    test execution by grouping tests with identical pre-allocation state.
 
     """
     console = Console()

src/ethereum_test_fixtures/shared_alloc.py

@@ -1,4 +1,4 @@
-"""Shared pre-allocation models for test fixture generation."""
+"""Pre-allocation group models for test fixture generation."""
 
 from pathlib import Path
 from typing import Any, Dict, List
@@ -15,10 +15,10 @@
 
 class SharedPreStateGroup(CamelModel):
     """
-    Shared pre-state group for tests with identical Environment and fork values.
+    Pre-allocation group for tests with identical Environment and fork values.
 
     Groups tests by a hash of their fixture Environment and fork to enable
-    shared pre-allocation optimization.
+    pre-allocation group optimization.
     """
 
     model_config = {"populate_by_name": True}  # Allow both field names and aliases

src/ethereum_test_specs/base.py

@@ -218,20 +218,20 @@ def get_genesis_environment(self, fork: Fork) -> Environment:
             "pre-allocation"
         )
 
-    def update_shared_pre_state(
-        self, shared_pre_state: SharedPreState, fork: Fork, test_id: str
+    def update_pre_alloc_groups(
+        self, pre_alloc_groups: SharedPreState, fork: Fork, test_id: str
     ) -> SharedPreState:
-        """Create or update the shared pre-state group with the pre from the current spec."""
+        """Create or update the pre-allocation group with the pre from the current spec."""
         if not hasattr(self, "pre"):
             raise AttributeError(
-                f"{self.__class__.__name__} does not have a 'pre' field. Shared pre-allocation "
-                "is only supported for test types that define pre-allocation."
+                f"{self.__class__.__name__} does not have a 'pre' field. Pre-allocation groups "
+                "are only supported for test types that define pre-allocation."
             )
-        pre_alloc_hash = self.compute_shared_pre_alloc_hash(fork=fork)
+        pre_alloc_hash = self.compute_pre_alloc_group_hash(fork=fork)
 
-        if pre_alloc_hash in shared_pre_state:
+        if pre_alloc_hash in pre_alloc_groups:
             # Update existing group - just merge pre-allocations
-            group = shared_pre_state[pre_alloc_hash]
+            group = pre_alloc_groups[pre_alloc_hash]
             group.pre = Alloc.merge(
                 group.pre,
                 self.pre,
@@ -241,7 +241,7 @@ def update_shared_pre_state(
             group.test_ids.append(str(test_id))
             group.test_count = len(group.test_ids)
             group.pre_account_count = len(group.pre.root)
-            shared_pre_state[pre_alloc_hash] = group
+            pre_alloc_groups[pre_alloc_hash] = group
         else:
             # Create new group - use Environment instead of expensive genesis generation
             group = SharedPreStateGroup(
@@ -252,11 +252,11 @@ def update_shared_pre_state(
                 environment=self.get_genesis_environment(fork),
                 pre=self.pre,
             )
-            shared_pre_state[pre_alloc_hash] = group
-        return shared_pre_state
+            pre_alloc_groups[pre_alloc_hash] = group
+        return pre_alloc_groups
 
-    def compute_shared_pre_alloc_hash(self, fork: Fork) -> str:
-        """Hash (fork, env) in order to group tests by shared genesis config."""
+    def compute_pre_alloc_group_hash(self, fork: Fork) -> str:
+        """Hash (fork, env) in order to group tests by genesis config."""
         if not hasattr(self, "pre"):
             raise AttributeError(
                 f"{self.__class__.__name__} does not have a 'pre' field. Shared pre-allocation "