@bananapus/ownable-v6 0.0.7 → 0.0.9

package/STYLE_GUIDE.md

@@ -17,8 +17,6 @@ src/
 
 One contract/interface/struct/enum per file. Name the file after the type it contains.
 
-**Structs, enums, libraries, and interfaces always go in their subdirectories** (`src/structs/`, `src/enums/`, `src/libraries/`, `src/interfaces/`) — never inline in contract files or placed in `src/` root. This keeps type definitions discoverable and import paths consistent across repos.
-
 ## Pragma Versions
 
 ```solidity
@@ -106,14 +104,6 @@ contract JBExample is JBPermissioned, IJBExample {
     // -------------------------- constructor ---------------------------- //
     //*********************************************************************//
 
-    //*********************************************************************//
-    // ---------------------- receive / fallback ------------------------- //
-    //*********************************************************************//
-
-    //*********************************************************************//
-    // --------------------------- modifiers ----------------------------- //
-    //*********************************************************************//
-
     //*********************************************************************//
     // ---------------------- external transactions ---------------------- //
     //*********************************************************************//
@@ -141,28 +131,23 @@ contract JBExample is JBPermissioned, IJBExample {
 ```
 
 **Section order:**
-1. `using` declarations
-2. Custom errors
-3. Public constants
-4. Internal constants
-5. Public immutable stored properties
-6. Internal immutable stored properties
-7. Public stored properties
-8. Internal stored properties
-9. Constructor
-10. `receive` / `fallback`
-11. Modifiers
-12. External transactions
-13. External views
-14. Public transactions
-15. Internal helpers
-16. Internal views
-17. Private helpers
+1. Custom errors
+2. Public constants
+3. Internal constants
+4. Public immutable stored properties
+5. Internal immutable stored properties
+6. Public stored properties
+7. Internal stored properties
+8. Constructor
+9. External transactions
+10. External views
+11. Public transactions
+12. Internal helpers
+13. Internal views
+14. Private helpers
 
 Functions are alphabetized within each section.
 
-**Events:** Events are declared in interfaces only, never in implementation contracts. Implementations inherit events from their interface and emit them unqualified. This keeps the ABI definition in one place and allows tests to use interface-qualified event expectations (e.g., `emit IJBController.LaunchProject(...)`).
-
 ## Interface Structure
 
 ```solidity
@@ -212,7 +197,7 @@ interface IJBExample is IJBBase {
 | Public/external function | `camelCase` | `cashOutTokensOf` |
 | Internal/private function | `_camelCase` | `_processFee` |
 | Internal storage | `_camelCase` | `_accountingContextForTokenOf` |
-| Function parameter | `camelCase` | `projectId`, `cashOutCount` |
+| Function parameter | `camelCase` (no underscores) | `projectId`, `cashOutCount` |
 
 ## NatSpec
 
@@ -268,9 +253,12 @@ uint256 public constant MAX_RESERVED_PERCENT = 10_000;
 
 ## Function Calls
 
-Use named parameters for readability when calling functions with 3+ arguments:
+Use named arguments for all function calls with 2 or more arguments — in both `src/` and `script/`:
 
 ```solidity
+// Good — named arguments
+token.mint({account: beneficiary, amount: count});
+_transferOwnership({newOwner: address(0), projectId: 0});
 PERMISSIONS.hasPermission({
     operator: sender,
     account: account,
@@ -279,8 +267,18 @@ PERMISSIONS.hasPermission({
     includeRoot: true,
     includeWildcardProjectId: true
 });
+
+// Bad — positional arguments with 2+ args
+token.mint(beneficiary, count);
+_transferOwnership(address(0), 0);
 ```
 
+Single-argument calls use positional style: `_burn(amount)`.
+
+This also applies to constructor calls, struct literals, and inherited/library calls (e.g., OZ `_mint`, `_safeMint`, `safeTransfer`, `allowance`, `Clones.cloneDeterministic`).
+
+Named argument keys must use **camelCase** — never underscores. If a function's parameter names use underscores, rename them to camelCase first.
+
 ## Multiline Signatures
 
 ```solidity
@@ -334,9 +332,6 @@ optimizer_runs = 200
 libs = ["node_modules", "lib"]
 fs_permissions = [{ access = "read-write", path = "./"}]
 
-[profile.ci_sizes]
-optimizer_runs = 200
-
 [fuzz]
 runs = 4096
 
@@ -351,10 +346,14 @@ multiline_func_header = "all"
 wrap_comments = true
 ```
 
-**Variations:**
-- `evm_version = 'cancun'` for repos using transient storage (buyback-hook, router-terminal, univ4-router)
-- `via_ir = true` for repos hitting stack-too-deep (buyback-hook, banny-retail, univ4-lp-split-hook, deploy-all)
-- `optimizer = false` only for deploy-all-v6 (stack-too-deep with optimization)
+**Optional sections (add only when needed):**
+- `[rpc_endpoints]` — repos with fork tests. Maps named endpoints to env vars (e.g. `ethereum = "${RPC_ETHEREUM_MAINNET}"`).
+- `[profile.ci_sizes]` — only when CI needs different optimizer settings than defaults for the size check step (e.g. `optimizer_runs = 200` when the default profile uses a lower value).
+
+**Common variations:**
+- `via_ir = true` when hitting stack-too-deep
+- `optimizer = false` when optimization causes stack-too-deep
+- `optimizer_runs` reduced when deep struct nesting causes stack-too-deep at 200 runs
 
 ### CI Workflows
 
@@ -384,8 +383,10 @@ jobs:
         uses: foundry-rs/foundry-toolchain@v1
       - name: Run tests
         run: forge test --fail-fast --summary --detailed --skip "*/script/**"
+        env:
+          RPC_ETHEREUM_MAINNET: ${{ secrets.RPC_ETHEREUM_MAINNET }}
       - name: Check contract sizes
-        run: FOUNDRY_PROFILE=ci_sizes forge build --sizes --skip "*/test/**" --skip "*/script/**" --skip SphinxUtils
+        run: forge build --sizes --skip "*/test/**" --skip "*/script/**" --skip SphinxUtils
 ```
 
 **lint.yml:**
@@ -407,11 +408,60 @@ jobs:
         run: forge fmt --check
 ```
 
+**slither.yml** (repos with `src/` contracts only):
+```yaml
+name: slither
+on:
+    pull_request:
+      branches:
+        - main
+    push:
+      branches:
+        - main
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: actions/setup-node@v4
+        with:
+          node-version: latest
+      - name: Install npm dependencies
+        run: npm install --omit=dev
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+      - name: Run slither
+        uses: crytic/slither-action@v0.3.1
+        with:
+            slither-config: slither-ci.config.json
+            fail-on: medium
+```
+
+**slither-ci.config.json:**
+```json
+{
+  "detectors_to_exclude": "timestamp,uninitialized-local,naming-convention,solc-version,shadowing-local",
+  "exclude_informational": true,
+  "exclude_low": false,
+  "exclude_medium": false,
+  "exclude_high": false,
+  "disable_color": false,
+  "filter_paths": "(mocks/|test/|node_modules/|lib/)",
+  "legacy_ast": false
+}
+```
+
+**Variations:**
+- Deployer-only repos (no `src/`, only `script/`) skip slither entirely — the action's internal `forge build` skips `test/` and `script/` by default, leaving nothing to compile.
+- Use inline `// slither-disable-next-line <detector>` to suppress known false positives rather than adding to `detectors_to_exclude` in the config. The comment must be on the line immediately before the flagged expression.
+
 ### package.json
 
 ```json
 {
-  "name": "@bananapus/ownable-v6",
+  "name": "@bananapus/package-name-v6",
   "version": "x.x.x",
   "license": "MIT",
   "repository": { "type": "git", "url": "git+https://github.com/Org/repo.git" },
@@ -431,13 +481,62 @@ jobs:
 
 ### remappings.txt
 
-Every repo has a `remappings.txt`. Minimal content:
+Every repo has a `remappings.txt` as the **single source of truth** for import remappings. Never add remappings to `foundry.toml`.
+
+**Principle:** Import paths in Solidity source must match npm package names exactly. With `libs = ["node_modules", "lib"]`, Foundry auto-resolves `@scope/package/path/File.sol` → `node_modules/@scope/package/path/File.sol`. No remapping needed for packages installed as real directories.
+
+**Note:** Auto-resolution does **not** work for symlinked packages (e.g. npm workspace links). Workspace repos like `deploy-all-v6` and `nana-cli-v6` need explicit `@scope/package/=node_modules/@scope/package/` remappings for each symlinked dependency.
+
+**Minimal content** (most repos):
 
 ```
-@sphinx-labs/contracts/=lib/sphinx/packages/contracts/contracts/foundry
+forge-std/=lib/forge-std/src/
 ```
 
-Additional mappings as needed for repo-specific dependencies.
+Only add extra remappings for:
+- **`forge-std`** — always needed (git submodule with `src/` subdirectory)
+- **Repo-specific `lib/` submodules** that have no npm package (e.g., `hookmate/=lib/hookmate/src/`)
+- **Symlinked npm packages** — need explicit `@scope/package/=node_modules/@scope/package/` entries
+- **Nested transitive deps** — e.g., `@chainlink/contracts-ccip/` nested inside `@bananapus/suckers-v6/node_modules/`
+
+**Never add remappings for:**
+- npm packages that match their import path and are installed as real directories — they auto-resolve
+- Short-form aliases (e.g., `@bananapus/core/` → `@bananapus/core-v6/src/`) — fix the import instead
+- Packages available via npm that are also git submodules — remove the submodule, use npm
+
+**Import path convention:**
+
+| Package | Import path | Resolves to |
+|---------|------------|-------------|
+| `@bananapus/core-v6` | `@bananapus/core-v6/src/libraries/JBConstants.sol` | `node_modules/@bananapus/core-v6/src/...` |
+| `@openzeppelin/contracts` | `@openzeppelin/contracts/token/ERC20/IERC20.sol` | `node_modules/@openzeppelin/contracts/...` |
+| `@uniswap/v4-core` | `@uniswap/v4-core/src/interfaces/IPoolManager.sol` | `node_modules/@uniswap/v4-core/src/...` |
+
+### Linting
+
+Solar (Foundry's built-in linter) runs automatically during `forge build`. It scans all `.sol` files in `libs` directories, including `node_modules`.
+
+**All test helpers must use relative imports** (e.g. `../../src/structs/JBRuleset.sol`), not bare `src/` imports. This ensures solar can resolve paths when the helper is consumed via npm in downstream repos.
+
+### Fork Tests
+
+Fork tests use named RPC endpoints defined in `[rpc_endpoints]` of `foundry.toml`. No skip guards — fork tests should hard-fail if the RPC endpoint is unavailable, making CI failures explicit.
+
+```solidity
+function setUp() public {
+    vm.createSelectFork("ethereum");
+    // ... setup code
+}
+```
+
+The endpoint name (e.g. `"ethereum"`) maps to an env var via `foundry.toml`:
+
+```toml
+[rpc_endpoints]
+ethereum = "${RPC_ETHEREUM_MAINNET}"
+```
+
+For multi-chain fork tests, add all needed endpoints.
 
 ### Formatting
 
@@ -465,4 +564,9 @@ CI checks formatting via `forge fmt --check`.
 
 ### Contract Size Checks
 
-CI runs `FOUNDRY_PROFILE=ci_sizes forge build --sizes` to catch contracts approaching the 24KB limit. The `ci_sizes` profile uses `optimizer_runs = 200` for realistic size measurement even when the default profile has different optimizer settings.
+CI runs `forge build --sizes` to catch contracts approaching the 24KB limit. When the repo's default `optimizer_runs` differs from what you want for size checking, use `FOUNDRY_PROFILE=ci_sizes forge build --sizes` with a `[profile.ci_sizes]` section in `foundry.toml`.
+
+
+## Repo-Specific Deviations
+
+None. This repo follows the standard configuration exactly.

package/foundry.lock

@@ -0,0 +1,5 @@
+{
+  "lib/forge-std": {
+    "rev": "77876f8a5b44b770a935621bb331660c90ac928e"
+  }
+}

package/foundry.toml

@@ -5,9 +5,6 @@ optimizer_runs = 200
 libs = ["node_modules", "lib"]
 fs_permissions = [{ access = "read-write", path = "./"}]
 
-[profile.ci_sizes]
-optimizer_runs = 200
-
 [fuzz]
 runs = 4096
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/ownable-v6",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -10,8 +10,9 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@bananapus/core-v6": "^0.0.11",
-    "@openzeppelin/contracts": "^5.0.2"
+    "@bananapus/core-v6": "^0.0.16",
+    "@bananapus/permission-ids-v6": "^0.0.9",
+    "@openzeppelin/contracts": "^5.6.1"
   },
   "scripts": {
     "test": "forge test",

package/src/JBOwnableOverrides.sol

@@ -75,7 +75,7 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
             revert JBOwnableOverrides_InvalidNewOwner();
         }
 
-        _transferOwnership(initialOwner, initialProjectIdOwner);
+        _transferOwnership({newOwner: initialOwner, projectId: initialProjectIdOwner});
     }
 
     //*********************************************************************//
@@ -140,7 +140,7 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
     /// @dev This can only be called by the current owner.
     function renounceOwnership() public virtual override {
         _checkOwner();
-        _transferOwnership(address(0), 0);
+        _transferOwnership({newOwner: address(0), projectId: 0});
     }
 
     /// @notice Sets the permission ID the owner can use to give other addresses owner access.
@@ -162,7 +162,7 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
             revert JBOwnableOverrides_InvalidNewOwner();
         }
 
-        _transferOwnership(newOwner, 0);
+        _transferOwnership({newOwner: newOwner, projectId: 0});
     }
 
     /// @notice Transfer ownership of this contract to a new Juicebox project.
@@ -181,7 +181,8 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
             revert JBOwnableOverrides_ProjectDoesNotExist();
         }
 
-        _transferOwnership(address(0), uint88(projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        _transferOwnership({newOwner: address(0), projectId: uint88(projectId)});
     }
 
     //*********************************************************************//
@@ -207,7 +208,7 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
     /// @notice Helper to allow for drop-in replacement of OpenZeppelin `Ownable`.
     /// @param newOwner The address that should receive ownership of this contract.
     function _transferOwnership(address newOwner) internal virtual {
-        _transferOwnership(newOwner, 0);
+        _transferOwnership({newOwner: newOwner, projectId: 0});
     }
 
     /// @notice Transfers this contract's ownership to an address (`newOwner`) OR a Juicebox project (`projectId`).
@@ -238,6 +239,6 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
         // This is to prevent permissions clashes for the new user/owner.
         jbOwner = JBOwner({owner: newOwner, projectId: projectId, permissionId: 0});
         // Emit a transfer event with the new owner's address.
-        _emitTransferEvent(oldOwner, newOwner, projectId);
+        _emitTransferEvent({previousOwner: oldOwner, newOwner: newOwner, newProjectId: projectId});
     }
 }

package/src/structs/JBOwner.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.0;
 /// `owner` address has owner access.
 /// @custom:member permissionId The permission ID which corresponds to owner access. See `JBPermissions` in `nana-core`
 /// and `nana-permission-ids`.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBOwner {
     address owner;
     uint88 projectId;

package/test/Ownable.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.26;
 
-import "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 import {MockOwnable} from "./mocks/MockOwnable.sol";
 import {JBOwnableOverrides} from "../src/JBOwnableOverrides.sol";
 
@@ -13,8 +13,8 @@ import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsDat
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 
 contract OwnableTest is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     modifier isNotContract(address a) {
         uint256 size;
@@ -27,9 +27,9 @@ contract OwnableTest is Test {
 
     function setUp() public {
         // Deploy the permissions contract.
-        PERMISSIONS = new JBPermissions(address(0));
+        permissions = new JBPermissions(address(0));
         // Deploy the projects contract.
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     function testDeployerDoesNotBecomeOwner(address deployer, address owner) public isNotContract(owner) {
@@ -37,7 +37,7 @@ contract OwnableTest is Test {
         vm.assume(owner != address(0));
 
         vm.prank(deployer);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, owner, uint88(0));
+        MockOwnable ownable = new MockOwnable(projects, permissions, owner, uint88(0));
 
         assertEq(owner, ownable.owner(), "Deployer did not become the owner.");
     }
@@ -56,17 +56,18 @@ contract OwnableTest is Test {
         vm.assume(newProjectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 projectId = PROJECTS.createFor(projectOwner);
+        uint256 projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Make sure the deployer owns it.
         assertEq(projectOwner, ownable.owner(), "Deployer is not the owner.");
 
         // Transfer the project's ownership.
         vm.prank(projectOwner);
-        PROJECTS.transferFrom(projectOwner, newProjectOwner, projectId);
+        projects.transferFrom(projectOwner, newProjectOwner, projectId);
 
         // Make sure the `Ownable` contract has also been transferred to the new project owner.
         assertEq(newProjectOwner, ownable.owner(), "Ownable did not follow the Project owner.");
@@ -86,10 +87,11 @@ contract OwnableTest is Test {
         vm.assume(projectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Make sure the project owner owns it.
         assertEq(projectOwner, ownable.owner(), "Deployer is not the owner.");
@@ -100,7 +102,7 @@ contract OwnableTest is Test {
         // Make sure it was transferred to the new owner.
         assertEq(newOwnableOwner, ownable.owner());
         // Sanity check to make sure it only the `Ownable` changed, and that the project did not.
-        assertEq(PROJECTS.ownerOf(_projectId), projectOwner);
+        assertEq(projects.ownerOf(_projectId), projectOwner);
     }
 
     function testCantTransferToProjectZero(address owner) public {
@@ -108,7 +110,7 @@ contract OwnableTest is Test {
         vm.startPrank(owner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, owner, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, owner, 0);
 
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
 
@@ -122,7 +124,7 @@ contract OwnableTest is Test {
         vm.startPrank(owner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, owner, uint88(0));
+        MockOwnable ownable = new MockOwnable(projects, permissions, owner, uint88(0));
 
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
 
@@ -145,18 +147,19 @@ contract OwnableTest is Test {
         vm.assume(newProjectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Make sure the project owner owns it.
         assertEq(projectOwner, ownable.owner(), "Deployer is not the owner.");
 
         // Transfer the project ownership.
         vm.prank(projectOwner);
-        PROJECTS.transferFrom(projectOwner, newProjectOwner, _projectId);
-        assertEq(PROJECTS.ownerOf(_projectId), newProjectOwner);
+        projects.transferFrom(projectOwner, newProjectOwner, _projectId);
+        assertEq(projects.ownerOf(_projectId), newProjectOwner);
 
         // Make sure the `Ownable` contract has also been transferred to the new project owner.
         assertEq(newProjectOwner, ownable.owner());
@@ -167,7 +170,7 @@ contract OwnableTest is Test {
         vm.assume(deployer != owner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, owner, uint88(0));
+        MockOwnable ownable = new MockOwnable(projects, permissions, owner, uint88(0));
 
         // Transfer ownership to the project owner.
         vm.prank(owner);
@@ -185,11 +188,12 @@ contract OwnableTest is Test {
         vm.assume(projectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
         vm.prank(deployer);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Renounce the ownership.
         vm.prank(projectOwner);
@@ -218,10 +222,11 @@ contract OwnableTest is Test {
         }
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Set the required permission.
         vm.prank(projectOwner);
@@ -254,8 +259,9 @@ contract OwnableTest is Test {
 
         // The owner gives permission to the caller.
         vm.prank(projectOwner);
-        PERMISSIONS.setPermissionsFor(
+        permissions.setPermissionsFor(
             projectOwner,
+            // forge-lint: disable-next-line(unsafe-typecast)
             JBPermissionsData({operator: callerAddress, projectId: uint56(_projectId), permissionIds: _permissionIds})
         );
 
@@ -296,10 +302,11 @@ contract OwnableTest is Test {
         }
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Set the permission that is required.
         ownable.setPermission(requiredPermissionId);
@@ -331,8 +338,9 @@ contract OwnableTest is Test {
 
         // The owner gives permission to the caller.
         vm.prank(projectOwner);
-        PERMISSIONS.setPermissionsFor(
+        permissions.setPermissionsFor(
             projectOwner,
+            // forge-lint: disable-next-line(unsafe-typecast)
             JBPermissionsData({operator: callerAddress, projectId: uint56(_projectId), permissionIds: _permissionIds})
         );
 
@@ -356,19 +364,20 @@ contract OwnableTest is Test {
         vm.assume(owner != address(0) && projectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Should revert because we set both a owner and a projectOwner
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
 
         // Create the `Ownable` contract.
-        new MockOwnable(PROJECTS, PERMISSIONS, address(owner), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        new MockOwnable(projects, permissions, address(owner), uint88(_projectId));
     }
 
     function testCantInitializeAsRenounced() public {
         // Should revert because we set both a owner and a projectOwner
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
         // Create the `Ownable` contract.
-        new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(0));
+        new MockOwnable(projects, permissions, address(0), uint88(0));
     }
 }

package/test/OwnableAttacks.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.26;
 
-import "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 import {MockOwnable} from "./mocks/MockOwnable.sol";
 import {JBOwnableOverrides} from "../src/JBOwnableOverrides.sol";
 
@@ -16,8 +16,8 @@ import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsDat
 /// @notice Adversarial security tests for JBOwnable covering edge cases
 ///         around dual ownership, permission semantics, and renounced contracts.
 contract OwnableAttacks is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     address alice = makeAddr("alice");
     address bob = makeAddr("bob");
@@ -33,25 +33,26 @@ contract OwnableAttacks is Test {
     }
 
     function setUp() public {
-        PERMISSIONS = new JBPermissions(address(0));
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        permissions = new JBPermissions(address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     // =========================================================================
     // Test 1: Constructor rejects both owner AND projectId set
     // =========================================================================
     function test_bothOwnerAndProjectId_constructorReverts() public {
-        uint256 projectId = PROJECTS.createFor(alice);
+        uint256 projectId = projects.createFor(alice);
 
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
-        new MockOwnable(PROJECTS, PERMISSIONS, bob, uint88(projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        new MockOwnable(projects, permissions, bob, uint88(projectId));
     }
 
     // =========================================================================
     // Test 2: Renounced contract — protectedMethod always reverts
     // =========================================================================
     function test_renounced_protectedMethodAlwaysReverts() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // Owner can call.
         vm.prank(alice);
@@ -82,8 +83,9 @@ contract OwnableAttacks is Test {
     /// @notice After any ownership transfer, permissionId should reset to 0.
     ///         This prevents stale permission delegation.
     function test_permissionIdResetOnTransfer() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Set permission ID.
         vm.prank(alice);
@@ -105,8 +107,9 @@ contract OwnableAttacks is Test {
     // =========================================================================
     /// @notice After transferring project NFT, old owner should lose access.
     function test_staleOwner_afterNFTTransfer() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Alice is current owner.
         assertEq(ownable.owner(), alice);
@@ -115,7 +118,7 @@ contract OwnableAttacks is Test {
 
         // Transfer project NFT to bob.
         vm.prank(alice);
-        PROJECTS.transferFrom(alice, bob, projectId);
+        projects.transferFrom(alice, bob, projectId);
 
         // Alice should no longer be owner.
         assertEq(ownable.owner(), bob, "Bob should be new owner");
@@ -135,7 +138,7 @@ contract OwnableAttacks is Test {
     // =========================================================================
     /// @notice transferOwnershipToProject with projectId > type(uint88).max should revert.
     function test_transferOwnershipToProject_overflowReverts() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // type(uint88).max + 1 = 309485009821345068724781056
         uint256 overflowId = uint256(type(uint88).max) + 1;
@@ -152,11 +155,12 @@ contract OwnableAttacks is Test {
     ///         doesn't grant access to a different project's JBOwnable.
     function test_rootOnWrongProject_noAccess() public {
         // Create two projects.
-        uint256 aliceProject = PROJECTS.createFor(alice);
-        uint256 attackerProject = PROJECTS.createFor(attacker);
+        uint256 aliceProject = projects.createFor(alice);
+        uint256 attackerProject = projects.createFor(attacker);
 
         // Ownable is owned by alice's project.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(aliceProject));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(aliceProject));
 
         // Set permission ID so delegated access is possible.
         vm.prank(alice);
@@ -167,8 +171,9 @@ contract OwnableAttacks is Test {
         rootPerms[0] = 1; // ROOT
 
         vm.prank(attacker);
-        PERMISSIONS.setPermissionsFor(
+        permissions.setPermissionsFor(
             attacker,
+            // forge-lint: disable-next-line(unsafe-typecast)
             JBPermissionsData({operator: attacker, projectId: uint56(attackerProject), permissionIds: rootPerms})
         );
 

package/test/OwnableEdgeCases.t.sol

@@ -1,14 +1,12 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.26;
 
-import "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 import {MockOwnable} from "./mocks/MockOwnable.sol";
 import {JBOwnableOverrides} from "../src/JBOwnableOverrides.sol";
-import {JBOwner} from "../src/structs/JBOwner.sol";
 import {IJBOwnable} from "../src/interfaces/IJBOwnable.sol";
 
 import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
-import {JBPermissioned} from "@bananapus/core-v6/src/abstract/JBPermissioned.sol";
 import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
@@ -18,8 +16,8 @@ import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsDat
 /// @notice Edge case and gap tests for JBOwnable: multi-hop NFT transfers,
 ///         project-to-project ownership, permissionId lifecycle, and nonexistent projects.
 contract OwnableEdgeCases is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     address alice = makeAddr("alice");
     address bob = makeAddr("bob");
@@ -36,32 +34,33 @@ contract OwnableEdgeCases is Test {
     }
 
     function setUp() public {
-        PERMISSIONS = new JBPermissions(address(0));
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        permissions = new JBPermissions(address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     // =========================================================================
     // Test 1: Multi-hop NFT transfer — ownership follows through A→B→C→D
     // =========================================================================
     function test_multiHopNFTTransfer_ownerFollows() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         assertEq(ownable.owner(), alice);
 
         // Transfer NFT: alice → bob
         vm.prank(alice);
-        PROJECTS.transferFrom(alice, bob, projectId);
+        projects.transferFrom(alice, bob, projectId);
         assertEq(ownable.owner(), bob, "Should follow to bob");
 
         // Transfer NFT: bob → charlie
         vm.prank(bob);
-        PROJECTS.transferFrom(bob, charlie, projectId);
+        projects.transferFrom(bob, charlie, projectId);
         assertEq(ownable.owner(), charlie, "Should follow to charlie");
 
         // Transfer NFT: charlie → dave
         vm.prank(charlie);
-        PROJECTS.transferFrom(charlie, dave, projectId);
+        projects.transferFrom(charlie, dave, projectId);
         assertEq(ownable.owner(), dave, "Should follow to dave");
 
         // dave can call protectedMethod, alice/bob/charlie cannot
@@ -85,10 +84,11 @@ contract OwnableEdgeCases is Test {
     // Test 2: Transfer project → different project
     // =========================================================================
     function test_transferProjectToProject() public {
-        uint256 projectA = PROJECTS.createFor(alice);
-        uint256 projectB = PROJECTS.createFor(bob);
+        uint256 projectA = projects.createFor(alice);
+        uint256 projectB = projects.createFor(bob);
 
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectA));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectA));
         assertEq(ownable.owner(), alice);
 
         // Transfer ownership from project A to project B.
@@ -112,11 +112,11 @@ contract OwnableEdgeCases is Test {
     // Test 3: Full ownership cycle: address → project → address → project
     // =========================================================================
     function test_fullOwnershipCycle() public {
-        uint256 projectA = PROJECTS.createFor(alice);
-        uint256 projectB = PROJECTS.createFor(bob);
+        uint256 projectA = projects.createFor(alice);
+        uint256 projectB = projects.createFor(bob);
 
         // Start with address ownership.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, charlie, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, charlie, 0);
         assertEq(ownable.owner(), charlie);
 
         // charlie → project A (alice)
@@ -137,6 +137,7 @@ contract OwnableEdgeCases is Test {
         // Verify jbOwner struct is correct (projectId set, owner zeroed).
         (address storedOwner, uint88 storedProjectId, uint8 storedPermId) = ownable.jbOwner();
         assertEq(storedOwner, address(0), "owner field should be zero in project mode");
+        // forge-lint: disable-next-line(unsafe-typecast)
         assertEq(storedProjectId, uint88(projectB), "projectId should be projectB");
         assertEq(storedPermId, 0, "permissionId should be 0");
     }
@@ -145,9 +146,10 @@ contract OwnableEdgeCases is Test {
     // Test 4: permissionId lifecycle through multiple transfers
     // =========================================================================
     function test_permissionIdLifecycle() public {
-        uint256 projectA = PROJECTS.createFor(alice);
+        uint256 projectA = projects.createFor(alice);
 
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectA));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectA));
 
         // Set permissionId to 42.
         vm.prank(alice);
@@ -192,7 +194,7 @@ contract OwnableEdgeCases is Test {
     function test_nonOwnerCannotSetPermissionId(address nonOwner) public {
         vm.assume(nonOwner != alice && nonOwner != address(0));
 
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         vm.prank(nonOwner);
         vm.expectRevert();
@@ -204,8 +206,8 @@ contract OwnableEdgeCases is Test {
     // =========================================================================
     function test_transferToNonexistentProject_reverts() public {
         // Create one project so count == 1.
-        PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        projects.createFor(alice);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // Project 2 doesn't exist.
         vm.prank(alice);
@@ -223,8 +225,9 @@ contract OwnableEdgeCases is Test {
     //         transferred, old delegate loses access
     // =========================================================================
     function test_delegatedAccess_lostAfterNFTTransfer() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Set permissionId so delegation is possible.
         vm.prank(alice);
@@ -234,8 +237,10 @@ contract OwnableEdgeCases is Test {
         uint8[] memory permIds = new uint8[](1);
         permIds[0] = 42;
         vm.prank(alice);
-        PERMISSIONS.setPermissionsFor(
-            alice, JBPermissionsData({operator: charlie, projectId: uint56(projectId), permissionIds: permIds})
+        permissions.setPermissionsFor(
+            // forge-lint: disable-next-line(unsafe-typecast)
+            alice,
+            JBPermissionsData({operator: charlie, projectId: uint56(projectId), permissionIds: permIds})
         );
 
         // Charlie can call protectedMethod (delegated via permissions).
@@ -244,7 +249,7 @@ contract OwnableEdgeCases is Test {
 
         // Transfer NFT to bob.
         vm.prank(alice);
-        PROJECTS.transferFrom(alice, bob, projectId);
+        projects.transferFrom(alice, bob, projectId);
 
         // Charlie's delegation was from alice. Now owner is bob.
         // Charlie should lose access because _checkOwner resolves to bob,
@@ -262,7 +267,7 @@ contract OwnableEdgeCases is Test {
     // Test 8: OwnershipTransferred event emitted correctly
     // =========================================================================
     function test_ownershipTransferredEvent() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // Transfer to bob — expect event.
         vm.expectEmit(true, true, false, true);
@@ -276,7 +281,7 @@ contract OwnableEdgeCases is Test {
     // Test 9: PermissionIdChanged event emitted correctly
     // =========================================================================
     function test_permissionIdChangedEvent() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         vm.expectEmit(true, true, false, true);
         emit IJBOwnable.PermissionIdChanged(42, alice);
@@ -291,8 +296,8 @@ contract OwnableEdgeCases is Test {
     function testFuzz_transferToProject(address projectOwner) public isNotContract(projectOwner) {
         vm.assume(projectOwner != address(0));
 
-        uint256 projectId = PROJECTS.createFor(projectOwner);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        uint256 projectId = projects.createFor(projectOwner);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         vm.prank(alice);
         ownable.transferOwnershipToProject(projectId);
@@ -302,6 +307,7 @@ contract OwnableEdgeCases is Test {
         // Verify jbOwner struct.
         (address storedOwner, uint88 storedProjectId,) = ownable.jbOwner();
         assertEq(storedOwner, address(0), "stored owner should be zero");
+        // forge-lint: disable-next-line(unsafe-typecast)
         assertEq(storedProjectId, uint88(projectId), "stored projectId should match");
     }
 
@@ -311,8 +317,8 @@ contract OwnableEdgeCases is Test {
     /// @notice After renouncing, no one can call transferOwnership, transferOwnershipToProject,
     ///         setPermissionId, or renounceOwnership again.
     function test_renouncedContract_cannotReclaim() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        uint256 projectId = projects.createFor(alice);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         vm.prank(alice);
         ownable.renounceOwnership();
@@ -349,7 +355,7 @@ contract OwnableEdgeCases is Test {
     ///         NOT ERC2771Context. This test documents that a trusted forwarder
     ///         appending a sender address to calldata does NOT affect _checkOwner.
     function test_noERC2771_trustedForwarderHasNoEffect() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // Simulate what a trusted forwarder would do: call with alice's address
         // appended to calldata. Since JBOwnable uses plain Context, this has no effect.

package/test/OwnableInvariantTests.sol

@@ -4,15 +4,6 @@ pragma solidity ^0.8.26;
 import {Test} from "forge-std/Test.sol";
 import {OwnableHandler} from "./handlers/OwnableHandler.sol";
 
-import {MockOwnable} from "./mocks/MockOwnable.sol";
-import {JBOwnableOverrides} from "../src/JBOwnableOverrides.sol";
-import {JBOwner} from "../src/structs/JBOwner.sol";
-import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
-import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
-import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsData.sol";
-import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
-import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
-
 contract OwnableInvariantTests is Test {
     OwnableHandler handler;
 

package/test/handlers/OwnableHandler.sol

@@ -5,12 +5,9 @@ pragma solidity ^0.8.26;
 import {CommonBase} from "forge-std/Base.sol";
 import {StdCheats} from "forge-std/StdCheats.sol";
 import {StdUtils} from "forge-std/StdUtils.sol";
-import {console} from "forge-std/console.sol";
-
-import {MockOwnable, JBOwnableOverrides} from "../mocks/MockOwnable.sol";
+import {MockOwnable} from "../mocks/MockOwnable.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
-import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsData.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
 

package/test/mocks/MockOwnable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.26;
 
-import {JBOwnable, JBOwnableOverrides} from "../../src/JBOwnable.sol";
+import {JBOwnable} from "../../src/JBOwnable.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 

package/test/regression/{L65_BurnLockProtection.t.sol → BurnLockProtection.t.sol}

@@ -3,7 +3,6 @@ pragma solidity ^0.8.26;
 
 import {Test} from "forge-std/Test.sol";
 import {MockOwnable} from "../mocks/MockOwnable.sol";
-import {JBOwnableOverrides} from "../../src/JBOwnableOverrides.sol";
 
 import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
 import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
@@ -11,34 +10,35 @@ import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.s
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 
-/// @title L65_BurnLockProtection
+/// @title BurnLockProtection
 /// @notice Verifies that if a project NFT is burned/invalidated,
 ///         owner() returns address(0) and _checkOwner() reverts gracefully instead of
 ///         permanently locking the contract with an unrecoverable revert.
-contract L65_BurnLockProtection is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+contract BurnLockProtection is Test {
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     address alice = makeAddr("alice");
     address bob = makeAddr("bob");
 
     function setUp() public {
-        PERMISSIONS = new JBPermissions(address(0));
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        permissions = new JBPermissions(address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     /// @notice When a project NFT is burned (simulated via mockCallRevert), owner() should
     ///         return address(0) instead of reverting — contract degrades to "renounced" state.
     function test_burnedProjectNFT_ownerReturnsZero() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Verify normal operation first.
         assertEq(ownable.owner(), alice, "Owner should be alice before burn");
 
         // Simulate project NFT burn by making ownerOf revert for this projectId.
         vm.mockCallRevert(
-            address(PROJECTS), abi.encodeWithSelector(IERC721.ownerOf.selector, projectId), "ERC721: invalid token ID"
+            address(projects), abi.encodeWithSelector(IERC721.ownerOf.selector, projectId), "ERC721: invalid token ID"
         );
 
         // After burn, owner() should return address(0) — NOT revert.
@@ -50,8 +50,9 @@ contract L65_BurnLockProtection is Test {
     ///         Unauthorized error (not an unrecoverable ownerOf revert), making the contract
     ///         behave as if ownership was renounced.
     function test_burnedProjectNFT_checkOwnerRevertsGracefully() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Alice can call the protected method before burn.
         vm.prank(alice);
@@ -59,7 +60,7 @@ contract L65_BurnLockProtection is Test {
 
         // Simulate project NFT burn.
         vm.mockCallRevert(
-            address(PROJECTS), abi.encodeWithSelector(IERC721.ownerOf.selector, projectId), "ERC721: invalid token ID"
+            address(projects), abi.encodeWithSelector(IERC721.ownerOf.selector, projectId), "ERC721: invalid token ID"
         );
 
         // After burn, nobody can call protected methods — but the revert is graceful
@@ -75,7 +76,7 @@ contract L65_BurnLockProtection is Test {
 
     /// @notice Address-based ownership is unaffected by the try-catch change.
     function test_addressBasedOwnership_unaffectedByTryCatch() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         assertEq(ownable.owner(), alice, "Owner should be alice");
 
@@ -93,14 +94,15 @@ contract L65_BurnLockProtection is Test {
 
     /// @notice Normal project-based ownership still works correctly after the fix.
     function test_normalProjectOwnership_stillWorks() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         assertEq(ownable.owner(), alice);
 
         // Transfer project NFT.
         vm.prank(alice);
-        PROJECTS.transferFrom(alice, bob, projectId);
+        projects.transferFrom(alice, bob, projectId);
 
         assertEq(ownable.owner(), bob, "Owner should follow project NFT transfer");
 

package/test/regression/{L66_ZeroAddressValidation.t.sol → ZeroAddressValidation.t.sol}

@@ -10,19 +10,19 @@ import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 
-/// @title L66_ZeroAddressValidation
-/// @notice Verifies that deploying with a zero-address PROJECTS
+/// @title ZeroAddressValidation
+/// @notice Verifies that deploying with a zero-address projects
 ///         contract and a non-zero projectId reverts at construction time, preventing
 ///         permanently broken project-based ownership.
-contract L66_ZeroAddressValidation is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+contract ZeroAddressValidation is Test {
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     address alice = makeAddr("alice");
 
     function setUp() public {
-        PERMISSIONS = new JBPermissions(address(0));
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        permissions = new JBPermissions(address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     /// @notice Deploying with projects=address(0) and non-zero projectId must revert.
@@ -30,7 +30,7 @@ contract L66_ZeroAddressValidation is Test {
         vm.expectRevert(
             abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_ZeroAddressProjectsWithProjectOwner.selector)
         );
-        new MockOwnable(IJBProjects(address(0)), PERMISSIONS, address(0), uint88(1));
+        new MockOwnable(IJBProjects(address(0)), permissions, address(0), uint88(1));
     }
 
     /// @notice Fuzz: any non-zero projectId with projects=address(0) must revert.
@@ -40,27 +40,28 @@ contract L66_ZeroAddressValidation is Test {
         vm.expectRevert(
             abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_ZeroAddressProjectsWithProjectOwner.selector)
         );
-        new MockOwnable(IJBProjects(address(0)), PERMISSIONS, address(0), projectId);
+        new MockOwnable(IJBProjects(address(0)), permissions, address(0), projectId);
     }
 
     /// @notice Deploying with projects=address(0) and projectId=0 (address-based ownership)
     ///         should NOT revert for this error — it's valid as long as initialOwner != address(0).
     function test_zeroProjectsWithAddressOwnership_succeeds() public {
         // This is valid: address-based ownership with projects=address(0).
-        MockOwnable ownable = new MockOwnable(IJBProjects(address(0)), PERMISSIONS, alice, uint88(0));
+        MockOwnable ownable = new MockOwnable(IJBProjects(address(0)), permissions, alice, uint88(0));
         assertEq(ownable.owner(), alice, "Owner should be alice with address-based ownership");
     }
 
-    /// @notice Normal deployment with valid PROJECTS contract and projectId succeeds.
+    /// @notice Normal deployment with valid projects contract and projectId succeeds.
     function test_validProjectsWithProjectId_succeeds() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
         assertEq(ownable.owner(), alice, "Owner should be alice via project NFT");
     }
 
     /// @notice The existing check for both zero owner and zero projectId is still enforced.
     function test_bothZero_stillReverts() public {
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
-        new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(0));
+        new MockOwnable(projects, permissions, address(0), uint88(0));
     }
 }