docs(cheatcodes): standardize all cheatcode reference pages

Improve 100+ cheatcode reference pages with consistent formatting:

- Add frontmatter with SEO descriptions
- Consolidate function signatures into single code blocks
- Add parameter and return value tables
- Improve examples with Vocs file name syntax
- Add Gotchas sections with proper :::warning/:::note callouts
- Add Related Cheatcodes sections with cross-references
- Standardize See Also sections
- Replace emoji callouts with Vocs syntax
- Use :::code-group for multi-file examples (test file first)

Author: onbjerg

src/pages/reference/cheatcodes/accesses.mdx

@@ -1,40 +1,69 @@
+---
+description: Gets all storage slots that have been read or written to on an address
+---
+
 ## `accesses`
 
 ### Signature
 
 ```solidity
-function accesses(
-  address
-)
-external
-returns (
-  bytes32[] memory reads,
-  bytes32[] memory writes
-);
+function accesses(address target) external returns (bytes32[] memory reads, bytes32[] memory writes);
 ```
 
 ### Description
 
-Gets all storage slots that have been read (`reads`) or written to (`writes`) on an address.
+Gets all storage slots that have been read (`reads`) or written to (`writes`) on an address since [`record`](/reference/cheatcodes/record) was called.
+
+### Parameters
 
-Note that [`record`](/reference/cheatcodes/record.mdx) must be called first.
+| Parameter | Type      | Description                                     |
+|-----------|-----------|-------------------------------------------------|
+| `target`  | `address` | The address to get storage accesses for         |
 
-> ℹ️ **Note**
->
-> Every write also counts as an additional read.
+### Returns
+
+| Parameter | Type        | Description                            |
+|-----------|-------------|----------------------------------------|
+| `reads`   | `bytes32[]` | Array of storage slots that were read  |
+| `writes`  | `bytes32[]` | Array of storage slots that were written |
 
 ### Examples
 
-```solidity
-/// contract NumsContract {
-///     uint256 public num1 = 100; // slot 0
-///     uint256 public num2 = 200; // slot 1
-/// }
-
-vm.record();
-numsContract.num2();
-(bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(
-  address(numsContract)
-);
-emit log_uint(uint256(reads[0])); // 1
+:::code-group
+
+```solidity [test/Accesses.t.sol]
+function testAccesses() public {
+    vm.record();
+    numsContract.num2(); // reads slot 1
+    
+    (bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(
+        address(numsContract)
+    );
+    
+    assertEq(uint256(reads[0]), 1); // slot 1 was read
+    assertEq(writes.length, 0);
+}
+```
+
+```solidity [src/NumsContract.sol]
+contract NumsContract {
+    uint256 public num1 = 100; // slot 0
+    uint256 public num2 = 200; // slot 1
+}
 ```
+
+:::
+
+### Gotchas
+
+:::warning
+You must call [`record`](/reference/cheatcodes/record) before calling `accesses`, otherwise the returned arrays will be empty.
+:::
+
+:::note
+Every write also counts as an additional read. If you write to a slot, it will appear in both the `reads` and `writes` arrays.
+:::
+
+### Related Cheatcodes
+
+- [`record`](/reference/cheatcodes/record) - Starts recording storage accesses

src/pages/reference/cheatcodes/active-fork.mdx

@@ -1,33 +1,42 @@
+---
+description: Returns the identifier of the currently active fork
+---
+
 ## `activeFork`
 
 ### Signature
 
 ```solidity
-function activeFork() external returns (uint256);
+function activeFork() external view returns (uint256 forkId);
 ```
 
 ### Description
 
 Returns the identifier for the currently active fork. Reverts if no fork is currently active.
 
-### Examples
+### Returns
 
-Get the currently active fork id:
+| Parameter | Type      | Description                           |
+|-----------|-----------|---------------------------------------|
+| `forkId`  | `uint256` | Identifier of the active fork         |
 
-```solidity
-uint256 mainnetForkId = vm.createFork(MAINNET_RPC_URL);
-uint256 optimismForkId = vm.createFork(OPTIMISM_RPC_URL);
+### Examples
 
-assert(mainnetForkId != optimismForkId);
+```solidity [test/ActiveFork.t.sol]
+function testActiveFork() public {
+    uint256 mainnetFork = vm.createFork(MAINNET_RPC_URL);
+    uint256 optimismFork = vm.createFork(OPTIMISM_RPC_URL);
 
-vm.selectFork(mainnetForkId);
-assertEq(vm.activeFork(), mainnetForkId);
+    vm.selectFork(mainnetFork);
+    assertEq(vm.activeFork(), mainnetFork);
 
-vm.selectFork(optimismForkId);
-assertEq(vm.activeFork(), optimismForkId);
+    vm.selectFork(optimismFork);
+    assertEq(vm.activeFork(), optimismFork);
+}
 ```
 
-### SEE ALSO
+### Related Cheatcodes
 
-- [createFork](/reference/cheatcodes/create-fork.mdx)
-- [selectFork](/reference/cheatcodes/select-fork.mdx)
+- [`createFork`](/reference/cheatcodes/create-fork) - Create a new fork
+- [`selectFork`](/reference/cheatcodes/select-fork) - Select a fork
+- [`createSelectFork`](/reference/cheatcodes/create-select-fork) - Create and select a fork

src/pages/reference/cheatcodes/addr.mdx

@@ -1,18 +1,40 @@
+---
+description: Computes the address for a given private key
+---
+
 ## `addr`
 
 ### Signature
 
 ```solidity
-function addr(uint256 privateKey) external returns (address);
+function addr(uint256 privateKey) external returns (address keyAddr);
 ```
 
 ### Description
 
 Computes the address for a given private key.
 
+### Parameters
+
+| Parameter    | Type      | Description                  |
+|--------------|-----------|------------------------------|
+| `privateKey` | `uint256` | The private key to derive address from |
+
+### Returns
+
+| Type      | Description                          |
+|-----------|--------------------------------------|
+| `address` | The address corresponding to the private key |
+
 ### Examples
 
-```solidity
+```solidity [test/Addr.t.sol]
 address alice = vm.addr(1);
-emit log_address(alice); // 0x7e5f4552091a69125d5dfcb7b8c2659029395bdf
+emit log_address(alice); // 0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf
 ```
+
+### Related Cheatcodes
+
+- [`sign`](/reference/cheatcodes/sign) - Signs a digest with a private key
+- [`createWallet`](/reference/cheatcodes/create-wallet) - Creates a Wallet struct from a private key
+- [`deriveKey`](/reference/cheatcodes/derive-key) - Derives a private key from a mnemonic

src/pages/reference/cheatcodes/allow-cheatcodes.mdx

@@ -1,19 +1,46 @@
+---
+description: Grants cheatcode access to an address in forking mode
+---
+
 ## `allowCheatcodes`
 
 ### Signature
 
 ```solidity
-function allowCheatcodes(address) external;
+function allowCheatcodes(address account) external;
 ```
 
 ### Description
 
-In forking mode, explicitly grant the given address cheatcode access.
+In forking mode, explicitly grants the given address cheatcode access.
+
+By default, the test contract and its deployer have cheatcode access. Contracts deployed by addresses with cheatcode access also inherit it. However, contracts already deployed on the forked network do not have access.
+
+### Parameters
+
+| Parameter | Type      | Description                              |
+|-----------|-----------|------------------------------------------|
+| `account` | `address` | The address to grant cheatcode access to |
+
+### Examples
+
+```solidity [test/AllowCheatcodes.t.sol]
+function testAllowCheatcodes() public {
+    vm.createSelectFork(MAINNET_RPC_URL);
+    
+    // Grant cheatcode access to an existing on-chain contract
+    address existingContract = 0x1234...;
+    vm.allowCheatcodes(existingContract);
+}
+```
+
+### Gotchas
+
+:::note
+This is only useful for complex test setups in forking mode where you need existing on-chain contracts to use cheatcodes.
+:::
 
-By default, the test contract, and its deployer are allowed to access cheatcodes. In addition to that, cheat code
-access is granted if the contract was deployed by an address that already has cheatcode access.
-This will prevent cheatcode access from accounts already deployed on the forked network.
+### Related Cheatcodes
 
-> ℹ️ **Note**
->
-> This is only useful for more complex test setups in forking mode.
+- [`createFork`](/reference/cheatcodes/create-fork) - Create a fork
+- [`createSelectFork`](/reference/cheatcodes/create-select-fork) - Create and select a fork

src/pages/reference/cheatcodes/assume-no-revert.mdx

@@ -1,3 +1,7 @@
+---
+description: Discards fuzz inputs if the next call reverts
+---
+
 ## `assumeNoRevert`
 
 ### Signature
@@ -8,26 +12,39 @@ function assumeNoRevert() external;
 
 ### Description
 
-The fuzzer will discard the current fuzz inputs and start a new fuzz run if next call reverted.
-
-The test may fail if you hit the max number of rejects.
+The fuzzer will discard the current fuzz inputs and start a new fuzz run if the **next call** reverts.
 
-You can configure the rejection thresholds by setting [`fuzz.max_test_rejects`][max-test-rejects] in your `foundry.toml` file.
+This is useful when testing functions that have input validation, allowing the fuzzer to automatically find valid inputs.
 
 ### Examples
 
-For a function that requires an amount in certain range:
-```solidity
-function doSomething(uint256 amount) public {
-    require(amount > 100 ether && amount < 1_000 ether);
-}
-```
-reverts are discarded, resulting in test pass (or fail if max number of rejects hit):
-```solidity
-function testSomething(uint256 amount) public {
+:::code-group
+
+```solidity [test/AssumeNoRevert.t.sol]
+function testDoSomething(uint256 amount) public {
     vm.assumeNoRevert();
     target.doSomething(amount);
-    // [PASS]
+    // Passes if valid inputs are found
 }
 ```
 
+```solidity [src/Target.sol]
+function doSomething(uint256 amount) public {
+    require(amount > 100 ether && amount < 1_000 ether);
+    // ... logic
+}
+```
+
+:::
+
+### Gotchas
+
+:::warning
+The test may fail if you hit the max number of rejects (i.e., too many fuzz inputs cause reverts).
+
+Configure the rejection threshold with [`fuzz.max_test_rejects`](/config/reference/testing#max_test_rejects) in `foundry.toml`.
+:::
+
+### Related Cheatcodes
+
+- [`assume`](/reference/cheatcodes/assume) - Discard fuzz inputs based on a boolean condition

src/pages/reference/cheatcodes/assume.mdx

@@ -1,49 +1,67 @@
+---
+description: Discards fuzz inputs that don't satisfy a condition
+---
+
 ## `assume`
 
 ### Signature
 
 ```solidity
-function assume(bool) external;
+function assume(bool condition) external;
 ```
 
 ### Description
 
 If the boolean expression evaluates to false, the fuzzer will discard the current fuzz inputs and start a new fuzz run.
 
-The `assume` cheatcode should mainly be used for very narrow checks.
-Broad checks will slow down tests as it will take a while to find valid values, and the test may fail if you hit the max number of rejects.
-
-You can configure the rejection thresholds by setting [`fuzz.max_test_rejects`][max-test-rejects] in your `foundry.toml` file.
+Use `assume` for **narrow checks** where only specific values should be excluded. For broad range constraints, use [`bound`](/reference/forge-std/bound) instead.
 
-For broad checks, such as ensuring a `uint256` falls within a certain range, you can bound your input with the modulo operator or Forge Standard's [`bound`][forge-std-bound] method.
+### Parameters
 
-More information on filtering via `assume` can be found [here][filtering-guide].
+| Parameter   | Type   | Description                                      |
+|-------------|--------|--------------------------------------------------|
+| `condition` | `bool` | If false, the current fuzz run is discarded      |
 
 ### Examples
 
-```solidity
-// Good example of using assume
-function testSomething(uint256 a) public {
+#### Excluding specific values
+
+```solidity [test/Assume.t.sol]
+function testWithAssume(uint256 a) public {
     vm.assume(a != 1);
     require(a != 1);
     // [PASS]
 }
 ```
 
-```solidity
-// In this case assume is not a great fit, so you should bound inputs manually
-function testSomethingElse(uint256 a) public {
+#### Use bound for ranges instead
+
+```solidity [test/UseBound.t.sol]
+function testWithBound(uint256 a) public {
+    // Don't use assume for ranges - use bound instead
     a = bound(a, 100, 1e36);
     require(a >= 100 && a <= 1e36);
     // [PASS]
 }
 ```
 
-### SEE ALSO
+### Gotchas
+
+:::warning
+Broad checks will slow down tests significantly as the fuzzer struggles to find valid values. The test may fail if you hit the max number of rejects.
+
+Configure the rejection threshold with [`fuzz.max_test_rejects`](/config/reference/testing#max_test_rejects) in `foundry.toml`.
+:::
+
+:::note
+For range constraints, prefer [`bound`](/reference/forge-std/bound) or the modulo operator over `assume`. These approaches are much more efficient.
+:::
+
+### Related Cheatcodes
+
+- [`assumeNoRevert`](/reference/cheatcodes/assume-no-revert) - Discard fuzz inputs if the next call reverts
 
-Forge Standard Library
-[`bound`][forge-std-bound]
+### See Also
 
-[max-test-rejects]: /config/reference/testing#max_test_rejects
-[forge-std-bound]: /reference/forge-std/bound
-[filtering-guide]: https://altsysrq.github.io/proptest-book/proptest/tutorial/filtering.html#filtering
+- [`bound`](/reference/forge-std/bound) - Bound a value to a range
+- [Filtering Guide](https://altsysrq.github.io/proptest-book/proptest/tutorial/filtering.html#filtering) - More on filtering in property testing