diff --git a/test/ERC721/ERC721EnumerableFacet.t.sol b/test/ERC721/ERC721EnumerableFacet.t.sol
new file mode 100644
index 00000000..c8713e7e
--- /dev/null
+++ b/test/ERC721/ERC721EnumerableFacet.t.sol
@@ -0,0 +1,775 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+import {Test} from "forge-std/Test.sol";
+import {ERC721EnumerableFacet} from "../../src/token/ERC721/ERC721Enumerable/ERC721EnumerableFacet.sol";
+import {ERC721EnumerableFacetHarness} from "./harnesses/ERC721EnumerableFacetHarness.sol";
+
+contract ERC721EnumerableFacetTest is Test {
+    ERC721EnumerableFacetHarness public token;
+
+    address public alice;
+    address public bob;
+    address public charlie;
+
+    string constant TOKEN_NAME = "Test NFT";
+    string constant TOKEN_SYMBOL = "TNFT";
+    string constant TOKEN_BASE_URI = "https://api.example.com/metadata/";
+
+    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
+    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
+    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
+
+    function setUp() public {
+        alice = makeAddr("alice");
+        bob = makeAddr("bob");
+        charlie = makeAddr("charlie");
+
+        token = new ERC721EnumerableFacetHarness();
+        token.initialize(TOKEN_NAME, TOKEN_SYMBOL, TOKEN_BASE_URI);
+    }
+
+    // ============================================
+    // Metadata Tests
+    // ============================================
+
+    function test_Name() public view {
+        assertEq(token.name(), TOKEN_NAME);
+    }
+
+    function test_Symbol() public view {
+        assertEq(token.symbol(), TOKEN_SYMBOL);
+    }
+
+    function test_TokenURI() public {
+        token.mint(alice, 1);
+        assertEq(token.tokenURI(1), string.concat(TOKEN_BASE_URI, "1"));
+    }
+
+    function test_TokenURI_EmptyBaseURI() public {
+        ERC721EnumerableFacetHarness emptyToken = new ERC721EnumerableFacetHarness();
+        emptyToken.initialize("Empty", "EMPTY", "");
+        emptyToken.mint(alice, 1);
+        assertEq(emptyToken.tokenURI(1), "");
+    }
+
+    // ============================================
+    // Enumeration Tests
+    // ============================================
+
+    function test_TotalSupply() public view {
+        assertEq(token.totalSupply(), 0);
+    }
+
+    function test_TotalSupply_AfterMint() public {
+        token.mint(alice, 1);
+        assertEq(token.totalSupply(), 1);
+    }
+
+    function test_TotalSupply_AfterBurn() public {
+        token.mint(alice, 1);
+        vm.prank(alice);
+        token.burn(1);
+        assertEq(token.totalSupply(), 0);
+    }
+
+    function test_TokenOfOwnerByIndex() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(bob, 3);
+
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 1), 2);
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 3);
+    }
+
+    function test_TokenOfOwnerByIndex_AfterTransfer() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(alice, 3);
+
+        vm.prank(alice);
+        token.transferFrom(alice, bob, 2);
+
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 1), 3);
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 2);
+    }
+
+    function test_TokenOfOwnerByIndex_AfterBurn() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(alice, 3);
+
+        vm.prank(alice);
+        token.burn(2);
+
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 1), 3);
+    }
+
+    function test_Fuzz_TokenOfOwnerByIndex(uint256 numTokens) public {
+        vm.assume(numTokens > 0 && numTokens < 100);
+
+        for (uint256 i = 1; i <= numTokens; i++) {
+            token.mint(alice, i);
+        }
+
+        assertEq(token.balanceOf(alice), numTokens);
+        assertEq(token.totalSupply(), numTokens);
+
+        for (uint256 i = 0; i < numTokens; i++) {
+            assertEq(token.tokenOfOwnerByIndex(alice, i), i + 1);
+        }
+    }
+
+    function test_RevertWhen_TokenOfOwnerByIndexOutOfBounds() public {
+        token.mint(alice, 1);
+
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721OutOfBoundsIndex.selector, alice, 1));
+        token.tokenOfOwnerByIndex(alice, 1);
+    }
+
+    // ============================================
+    // Mint Tests
+    // ============================================
+
+    function test_Mint() public {
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(address(0), alice, 1);
+        token.mint(alice, 1);
+
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.balanceOf(alice), 1);
+        assertEq(token.totalSupply(), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+    }
+
+    function test_Mint_Multiple() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(bob, 3);
+
+        assertEq(token.balanceOf(alice), 2);
+        assertEq(token.balanceOf(bob), 1);
+        assertEq(token.totalSupply(), 3);
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.ownerOf(2), alice);
+        assertEq(token.ownerOf(3), bob);
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 1), 2);
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 3);
+    }
+
+    function test_Fuzz_Mint(address to, uint256 tokenId) public {
+        vm.assume(to != address(0));
+        vm.assume(tokenId > 0);
+
+        token.mint(to, tokenId);
+
+        assertEq(token.ownerOf(tokenId), to);
+        assertEq(token.balanceOf(to), 1);
+        assertEq(token.totalSupply(), 1);
+        assertEq(token.tokenOfOwnerByIndex(to, 0), tokenId);
+    }
+
+    function test_RevertWhen_MintToZeroAddress() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721InvalidReceiver.selector, address(0)));
+        token.mint(address(0), 1);
+    }
+
+    function test_RevertWhen_MintExistingToken() public {
+        token.mint(alice, 1);
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721InvalidSender.selector, address(0)));
+        token.mint(bob, 1);
+    }
+
+    // ============================================
+    // Burn Tests
+    // ============================================
+
+    function test_Burn() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, address(0), 1);
+        token.burn(1);
+
+        assertEq(token.totalSupply(), 0);
+        assertEq(token.balanceOf(alice), 0);
+
+        vm.expectRevert();
+        token.ownerOf(1);
+    }
+
+    function test_Burn_EntireBalance() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+
+        vm.startPrank(alice);
+        token.burn(1);
+        token.burn(2);
+        vm.stopPrank();
+
+        assertEq(token.balanceOf(alice), 0);
+        assertEq(token.totalSupply(), 0);
+    }
+
+    function test_Burn_UpdatesIndices() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(alice, 3);
+
+        vm.prank(alice);
+        token.burn(2);
+
+        assertEq(token.balanceOf(alice), 2);
+        assertEq(token.totalSupply(), 2);
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 1), 3);
+    }
+
+    function test_Fuzz_Burn(uint256 tokenId) public {
+        vm.assume(tokenId > 0);
+
+        token.mint(alice, tokenId);
+
+        vm.prank(alice);
+        token.burn(tokenId);
+
+        assertEq(token.totalSupply(), 0);
+        assertEq(token.balanceOf(alice), 0);
+
+        vm.expectRevert();
+        token.ownerOf(tokenId);
+    }
+
+    function test_RevertWhen_BurnNonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721NonexistentToken.selector, 1));
+        token.burn(1);
+    }
+
+    // ============================================
+    // Transfer Tests
+    // ============================================
+
+    function test_TransferFrom() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, bob, 1);
+        token.transferFrom(alice, bob, 1);
+
+        assertEq(token.ownerOf(1), bob);
+        assertEq(token.balanceOf(alice), 0);
+        assertEq(token.balanceOf(bob), 1);
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 1);
+    }
+
+    function test_TransferFrom_UpdatesIndices() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(alice, 3);
+
+        vm.prank(alice);
+        token.transferFrom(alice, bob, 2);
+
+        assertEq(token.balanceOf(alice), 2);
+        assertEq(token.balanceOf(bob), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 1), 3);
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 2);
+    }
+
+    function test_TransferFrom_ToSelf() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.transferFrom(alice, alice, 1);
+
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.balanceOf(alice), 1);
+    }
+
+    function test_Fuzz_TransferFrom(address to, uint256 tokenId) public {
+        vm.assume(to != address(0));
+        vm.assume(tokenId > 0);
+
+        token.mint(alice, tokenId);
+
+        vm.prank(alice);
+        token.transferFrom(alice, to, tokenId);
+
+        assertEq(token.ownerOf(tokenId), to);
+        assertEq(token.tokenOfOwnerByIndex(to, 0), tokenId);
+    }
+
+    function test_RevertWhen_TransferFromZeroAddressSender() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721NonexistentToken.selector, 1));
+        token.transferFrom(address(0), bob, 1);
+    }
+
+    function test_RevertWhen_TransferFromZeroAddressReceiver() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721InvalidReceiver.selector, address(0)));
+        token.transferFrom(alice, address(0), 1);
+    }
+
+    function test_RevertWhen_TransferFromNonExistentToken() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721NonexistentToken.selector, 1));
+        token.transferFrom(alice, bob, 1);
+    }
+
+    function test_RevertWhen_TransferFromIncorrectOwner() public {
+        token.mint(alice, 1);
+
+        vm.prank(bob);
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721InsufficientApproval.selector, bob, 1));
+        token.transferFrom(alice, charlie, 1);
+    }
+
+    function test_RevertWhen_TransferFromInsufficientApproval() public {
+        token.mint(alice, 1);
+
+        vm.prank(bob);
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721InsufficientApproval.selector, bob, 1));
+        token.transferFrom(alice, charlie, 1);
+    }
+
+    // ============================================
+    // Safe Transfer Tests
+    // ============================================
+
+    function test_SafeTransferFrom() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, bob, 1);
+        token.safeTransferFrom(alice, bob, 1);
+
+        assertEq(token.ownerOf(1), bob);
+    }
+
+    function test_SafeTransferFromWithData() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, bob, 1);
+        token.safeTransferFrom(alice, bob, 1, "0x1234");
+
+        assertEq(token.ownerOf(1), bob);
+    }
+
+    // ============================================
+    // Approval Tests
+    // ============================================
+
+    function test_Approve() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Approval(alice, bob, 1);
+        token.approve(bob, 1);
+
+        assertEq(token.getApproved(1), bob);
+    }
+
+    function test_Approve_UpdateExisting() public {
+        token.mint(alice, 1);
+
+        vm.startPrank(alice);
+        token.approve(bob, 1);
+        token.approve(charlie, 1);
+        vm.stopPrank();
+
+        assertEq(token.getApproved(1), charlie);
+    }
+
+    function test_Approve_ZeroAddress() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.approve(address(0), 1);
+
+        assertEq(token.getApproved(1), address(0));
+    }
+
+    function test_Fuzz_Approve(address approved, uint256 tokenId) public {
+        vm.assume(tokenId > 0);
+
+        token.mint(alice, tokenId);
+
+        vm.prank(alice);
+        token.approve(approved, tokenId);
+
+        assertEq(token.getApproved(tokenId), approved);
+    }
+
+    function test_RevertWhen_ApproveNonExistentToken() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721NonexistentToken.selector, 1));
+        token.approve(bob, 1);
+    }
+
+    function test_RevertWhen_ApproveIncorrectOwner() public {
+        token.mint(alice, 1);
+
+        vm.prank(bob);
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721InvalidApprover.selector, bob));
+        token.approve(charlie, 1);
+    }
+
+    // ============================================
+    // SetApprovalForAll Tests
+    // ============================================
+
+    function test_SetApprovalForAll() public {
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit ApprovalForAll(alice, bob, true);
+        token.setApprovalForAll(bob, true);
+
+        assertTrue(token.isApprovedForAll(alice, bob));
+    }
+
+    function test_SetApprovalForAll_Revoke() public {
+        vm.startPrank(alice);
+        token.setApprovalForAll(bob, true);
+        token.setApprovalForAll(bob, false);
+        vm.stopPrank();
+
+        assertFalse(token.isApprovedForAll(alice, bob));
+    }
+
+    function test_Fuzz_SetApprovalForAll(address operator, bool approved) public {
+        vm.assume(operator != address(0));
+
+        vm.prank(alice);
+        token.setApprovalForAll(operator, approved);
+
+        assertEq(token.isApprovedForAll(alice, operator), approved);
+    }
+
+    function test_RevertWhen_SetApprovalForAllZeroAddress() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721InvalidOperator.selector, address(0)));
+        token.setApprovalForAll(address(0), true);
+    }
+
+    // ============================================
+    // Operator Transfer Tests
+    // ============================================
+
+    function test_OperatorCanTransfer() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.setApprovalForAll(bob, true);
+
+        vm.prank(bob);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, charlie, 1);
+        token.transferFrom(alice, charlie, 1);
+
+        assertEq(token.ownerOf(1), charlie);
+    }
+
+    function test_ApprovedCanTransfer() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.approve(bob, 1);
+
+        vm.prank(bob);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, charlie, 1);
+        token.transferFrom(alice, charlie, 1);
+
+        assertEq(token.ownerOf(1), charlie);
+    }
+
+    function test_ApprovalClearedOnTransfer() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.approve(bob, 1);
+        assertEq(token.getApproved(1), bob);
+
+        vm.prank(alice);
+        token.transferFrom(alice, charlie, 1);
+        assertEq(token.getApproved(1), address(0));
+    }
+
+    // ============================================
+    // Error Cases Tests
+    // ============================================
+
+    function test_RevertWhen_BalanceOfZeroAddress() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721InvalidOwner.selector, address(0)));
+        token.balanceOf(address(0));
+    }
+
+    function test_RevertWhen_OwnerOfNonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721NonexistentToken.selector, 1));
+        token.ownerOf(1);
+    }
+
+    function test_RevertWhen_GetApprovedNonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721NonexistentToken.selector, 1));
+        token.getApproved(1);
+    }
+
+    function test_RevertWhen_TokenURINonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721EnumerableFacet.ERC721NonexistentToken.selector, 1));
+        token.tokenURI(1);
+    }
+
+    // ============================================
+    // Enumeration Bug Fix Tests
+    // ============================================
+
+    function test_EnumerationBugFix_MintSetsOwner() public {
+        // This test specifically verifies that the bug fix in our harness
+        // correctly sets the ownerOf mapping when minting
+        token.mint(alice, 1);
+
+        // Verify the token is properly owned
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.balanceOf(alice), 1);
+
+        // Verify enumeration works correctly
+        assertEq(token.totalSupply(), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+    }
+
+    function test_EnumerationBugFix_MintMultipleTokens() public {
+        // Test that the bug fix works for multiple tokens
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(bob, 3);
+
+        // Verify all tokens are properly owned
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.ownerOf(2), alice);
+        assertEq(token.ownerOf(3), bob);
+
+        // Verify enumeration is correct
+        assertEq(token.totalSupply(), 3);
+        assertEq(token.balanceOf(alice), 2);
+        assertEq(token.balanceOf(bob), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 1), 2);
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 3);
+    }
+
+    function test_EnumerationBugFix_TransferAfterMint() public {
+        // Test that transfers work correctly after the bug fix
+        token.mint(alice, 1);
+
+        // Verify initial state
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.balanceOf(alice), 1);
+
+        // Transfer should work correctly
+        vm.prank(alice);
+        token.transferFrom(alice, bob, 1);
+
+        // Verify transfer worked
+        assertEq(token.ownerOf(1), bob);
+        assertEq(token.balanceOf(alice), 0);
+        assertEq(token.balanceOf(bob), 1);
+
+        // Verify enumeration updated correctly
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 1);
+    }
+
+    function test_EnumerationBugFix_ApprovalAfterMint() public {
+        // Test that approvals work correctly after the bug fix
+        token.mint(alice, 1);
+
+        // Verify initial state
+        assertEq(token.ownerOf(1), alice);
+
+        // Approval should work correctly
+        vm.prank(alice);
+        token.approve(bob, 1);
+
+        // Verify approval worked
+        assertEq(token.getApproved(1), bob);
+
+        // Transfer using approval should work
+        vm.prank(bob);
+        token.transferFrom(alice, charlie, 1);
+
+        // Verify transfer worked
+        assertEq(token.ownerOf(1), charlie);
+    }
+
+    function test_EnumerationBugFix_BurnAfterMint() public {
+        // Test that burning works correctly after the bug fix
+        token.mint(alice, 1);
+
+        // Verify initial state
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.totalSupply(), 1);
+
+        // Burn should work correctly
+        vm.prank(alice);
+        token.burn(1);
+
+        // Verify burn worked
+        assertEq(token.totalSupply(), 0);
+        assertEq(token.balanceOf(alice), 0);
+
+        // Verify token no longer exists
+        vm.expectRevert();
+        token.ownerOf(1);
+    }
+
+    function test_EnumerationBugFix_ComplexScenario() public {
+        // Test a complex scenario that would fail with the original buggy library
+        // Mint multiple tokens to different owners
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(bob, 3);
+        token.mint(charlie, 4);
+
+        // Verify all tokens are properly owned
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.ownerOf(2), alice);
+        assertEq(token.ownerOf(3), bob);
+        assertEq(token.ownerOf(4), charlie);
+
+        // Verify enumeration
+        assertEq(token.totalSupply(), 4);
+        assertEq(token.balanceOf(alice), 2);
+        assertEq(token.balanceOf(bob), 1);
+        assertEq(token.balanceOf(charlie), 1);
+
+        // Perform transfers
+        vm.prank(alice);
+        token.transferFrom(alice, bob, 1);
+
+        vm.prank(bob);
+        token.transferFrom(bob, charlie, 3);
+
+        // Verify final state
+        assertEq(token.ownerOf(1), bob);
+        assertEq(token.ownerOf(2), alice);
+        assertEq(token.ownerOf(3), charlie);
+        assertEq(token.ownerOf(4), charlie);
+
+        // Verify enumeration updated correctly
+        assertEq(token.balanceOf(alice), 1);
+        assertEq(token.balanceOf(bob), 1);
+        assertEq(token.balanceOf(charlie), 2);
+
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 2);
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(charlie, 0), 4);
+        assertEq(token.tokenOfOwnerByIndex(charlie, 1), 3);
+    }
+
+    function testFuzz_EnumerationBugFix_ComplexScenario(uint256 numTokens) public {
+        vm.assume(numTokens > 0 && numTokens < 50);
+
+        // Mint tokens to alice
+        for (uint256 i = 1; i <= numTokens; i++) {
+            token.mint(alice, i);
+            assertEq(token.ownerOf(i), alice);
+        }
+
+        // Verify enumeration
+        assertEq(token.totalSupply(), numTokens);
+        assertEq(token.balanceOf(alice), numTokens);
+
+        // Transfer half to bob
+        uint256 halfTokens = numTokens / 2;
+        for (uint256 i = 1; i <= halfTokens; i++) {
+            vm.prank(alice);
+            token.transferFrom(alice, bob, i);
+            assertEq(token.ownerOf(i), bob);
+        }
+
+        // Verify final enumeration
+        assertEq(token.totalSupply(), numTokens);
+        assertEq(token.balanceOf(alice), numTokens - halfTokens);
+        assertEq(token.balanceOf(bob), halfTokens);
+    }
+
+    // ============================================
+    // Integration Tests
+    // ============================================
+
+    function test_MintTransferBurn_Flow() public {
+        token.mint(alice, 1);
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.totalSupply(), 1);
+
+        vm.prank(alice);
+        token.transferFrom(alice, bob, 1);
+        assertEq(token.ownerOf(1), bob);
+        assertEq(token.totalSupply(), 1);
+
+        vm.prank(bob);
+        token.burn(1);
+        assertEq(token.totalSupply(), 0);
+
+        vm.expectRevert();
+        token.ownerOf(1);
+    }
+
+    function test_ApproveTransferFromBurn_Flow() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.approve(bob, 1);
+
+        vm.prank(bob);
+        token.transferFrom(alice, charlie, 1);
+        assertEq(token.ownerOf(1), charlie);
+
+        vm.prank(charlie);
+        token.burn(1);
+        assertEq(token.totalSupply(), 0);
+
+        vm.expectRevert();
+        token.ownerOf(1);
+    }
+
+    function test_EnumerationAfterMultipleTransfers() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(alice, 3);
+        token.mint(alice, 4);
+
+        assertEq(token.balanceOf(alice), 4);
+        assertEq(token.totalSupply(), 4);
+
+        vm.prank(alice);
+        token.transferFrom(alice, bob, 2);
+
+        assertEq(token.balanceOf(alice), 3);
+        assertEq(token.balanceOf(bob), 1);
+        assertEq(token.totalSupply(), 4);
+
+        vm.prank(alice);
+        token.transferFrom(alice, bob, 4);
+
+        assertEq(token.balanceOf(alice), 2);
+        assertEq(token.balanceOf(bob), 2);
+
+        assertEq(token.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(token.tokenOfOwnerByIndex(alice, 1), 3);
+        assertEq(token.tokenOfOwnerByIndex(bob, 0), 2);
+        assertEq(token.tokenOfOwnerByIndex(bob, 1), 4);
+    }
+}
diff --git a/test/ERC721/ERC721Facet.t.sol b/test/ERC721/ERC721Facet.t.sol
new file mode 100644
index 00000000..ceb014ba
--- /dev/null
+++ b/test/ERC721/ERC721Facet.t.sol
@@ -0,0 +1,447 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+import {Test} from "forge-std/Test.sol";
+import {ERC721Facet} from "../../src/token/ERC721/ERC721/ERC721Facet.sol";
+import {ERC721FacetHarness} from "./harnesses/ERC721FacetHarness.sol";
+
+contract ERC721FacetTest is Test {
+    ERC721FacetHarness public token;
+
+    address public alice;
+    address public bob;
+    address public charlie;
+
+    string constant TOKEN_NAME = "Test NFT";
+    string constant TOKEN_SYMBOL = "TNFT";
+    string constant TOKEN_BASE_URI = "https://api.example.com/metadata/";
+
+    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
+    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
+    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
+
+    function setUp() public {
+        alice = makeAddr("alice");
+        bob = makeAddr("bob");
+        charlie = makeAddr("charlie");
+
+        token = new ERC721FacetHarness();
+        token.initialize(TOKEN_NAME, TOKEN_SYMBOL, TOKEN_BASE_URI);
+    }
+
+    // ============================================
+    // Metadata Tests
+    // ============================================
+
+    function test_Name() public view {
+        assertEq(token.name(), TOKEN_NAME);
+    }
+
+    function test_Symbol() public view {
+        assertEq(token.symbol(), TOKEN_SYMBOL);
+    }
+
+    function test_TokenURI() public {
+        token.mint(alice, 1);
+        assertEq(token.tokenURI(1), string.concat(TOKEN_BASE_URI, "1"));
+    }
+
+    function test_TokenURI_EmptyBaseURI() public {
+        ERC721FacetHarness emptyToken = new ERC721FacetHarness();
+        emptyToken.initialize("Empty", "EMPTY", "");
+        emptyToken.mint(alice, 1);
+        assertEq(emptyToken.tokenURI(1), "");
+    }
+
+    // ============================================
+    // Mint Tests
+    // ============================================
+
+    function test_Mint() public {
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(address(0), alice, 1);
+        token.mint(alice, 1);
+
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.balanceOf(alice), 1);
+    }
+
+    function test_Mint_Multiple() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+        token.mint(bob, 3);
+
+        assertEq(token.balanceOf(alice), 2);
+        assertEq(token.balanceOf(bob), 1);
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.ownerOf(2), alice);
+        assertEq(token.ownerOf(3), bob);
+    }
+
+    function test_Fuzz_Mint(address to, uint256 tokenId) public {
+        vm.assume(to != address(0));
+        vm.assume(tokenId > 0);
+
+        token.mint(to, tokenId);
+
+        assertEq(token.ownerOf(tokenId), to);
+        assertEq(token.balanceOf(to), 1);
+    }
+
+    function test_RevertWhen_MintToZeroAddress() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721InvalidReceiver.selector, address(0)));
+        token.mint(address(0), 1);
+    }
+
+    function test_RevertWhen_MintExistingToken() public {
+        token.mint(alice, 1);
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721InvalidSender.selector, address(0)));
+        token.mint(bob, 1);
+    }
+
+    // ============================================
+    // Burn Tests
+    // ============================================
+
+    function test_Burn() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, address(0), 1);
+        token.burn(1);
+
+        vm.expectRevert();
+        token.ownerOf(1);
+    }
+
+    function test_Burn_EntireBalance() public {
+        token.mint(alice, 1);
+        token.mint(alice, 2);
+
+        vm.startPrank(alice);
+        token.burn(1);
+        token.burn(2);
+        vm.stopPrank();
+
+        assertEq(token.balanceOf(alice), 0);
+    }
+
+    function test_Fuzz_Burn(uint256 tokenId) public {
+        vm.assume(tokenId > 0);
+
+        token.mint(alice, tokenId);
+
+        vm.prank(alice);
+        token.burn(tokenId);
+
+        vm.expectRevert();
+        token.ownerOf(tokenId);
+    }
+
+    function test_RevertWhen_BurnNonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721NonexistentToken.selector, 1));
+        token.burn(1);
+    }
+
+    // ============================================
+    // Transfer Tests
+    // ============================================
+
+    function test_TransferFrom() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, bob, 1);
+        token.transferFrom(alice, bob, 1);
+
+        assertEq(token.ownerOf(1), bob);
+        assertEq(token.balanceOf(alice), 0);
+        assertEq(token.balanceOf(bob), 1);
+    }
+
+    function test_TransferFrom_ToSelf() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.transferFrom(alice, alice, 1);
+
+        assertEq(token.ownerOf(1), alice);
+        assertEq(token.balanceOf(alice), 1);
+    }
+
+    function test_Fuzz_TransferFrom(address to, uint256 tokenId) public {
+        vm.assume(to != address(0));
+        vm.assume(tokenId > 0);
+
+        token.mint(alice, tokenId);
+
+        vm.prank(alice);
+        token.transferFrom(alice, to, tokenId);
+
+        assertEq(token.ownerOf(tokenId), to);
+    }
+
+    function test_RevertWhen_TransferFromZeroAddressSender() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721NonexistentToken.selector, 1));
+        token.transferFrom(address(0), bob, 1);
+    }
+
+    function test_RevertWhen_TransferFromZeroAddressReceiver() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721InvalidReceiver.selector, address(0)));
+        token.transferFrom(alice, address(0), 1);
+    }
+
+    function test_RevertWhen_TransferFromNonExistentToken() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721NonexistentToken.selector, 1));
+        token.transferFrom(alice, bob, 1);
+    }
+
+    function test_RevertWhen_TransferFromIncorrectOwner() public {
+        token.mint(alice, 1);
+
+        vm.prank(bob);
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721InsufficientApproval.selector, bob, 1));
+        token.transferFrom(alice, charlie, 1);
+    }
+
+    function test_RevertWhen_TransferFromInsufficientApproval() public {
+        token.mint(alice, 1);
+
+        vm.prank(bob);
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721InsufficientApproval.selector, bob, 1));
+        token.transferFrom(alice, charlie, 1);
+    }
+
+    // ============================================
+    // Safe Transfer Tests
+    // ============================================
+
+    function test_SafeTransferFrom() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, bob, 1);
+        token.safeTransferFrom(alice, bob, 1);
+
+        assertEq(token.ownerOf(1), bob);
+    }
+
+    function test_SafeTransferFromWithData() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, bob, 1);
+        token.safeTransferFrom(alice, bob, 1, "0x1234");
+
+        assertEq(token.ownerOf(1), bob);
+    }
+
+    // ============================================
+    // Approval Tests
+    // ============================================
+
+    function test_Approve() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Approval(alice, bob, 1);
+        token.approve(bob, 1);
+
+        assertEq(token.getApproved(1), bob);
+    }
+
+    function test_Approve_UpdateExisting() public {
+        token.mint(alice, 1);
+
+        vm.startPrank(alice);
+        token.approve(bob, 1);
+        token.approve(charlie, 1);
+        vm.stopPrank();
+
+        assertEq(token.getApproved(1), charlie);
+    }
+
+    function test_Approve_ZeroAddress() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.approve(address(0), 1);
+
+        assertEq(token.getApproved(1), address(0));
+    }
+
+    function test_Fuzz_Approve(address approved, uint256 tokenId) public {
+        vm.assume(tokenId > 0);
+
+        token.mint(alice, tokenId);
+
+        vm.prank(alice);
+        token.approve(approved, tokenId);
+
+        assertEq(token.getApproved(tokenId), approved);
+    }
+
+    function test_RevertWhen_ApproveNonExistentToken() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721NonexistentToken.selector, 1));
+        token.approve(bob, 1);
+    }
+
+    function test_RevertWhen_ApproveIncorrectOwner() public {
+        token.mint(alice, 1);
+
+        vm.prank(bob);
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721InvalidApprover.selector, bob));
+        token.approve(charlie, 1);
+    }
+
+    // ============================================
+    // SetApprovalForAll Tests
+    // ============================================
+
+    function test_SetApprovalForAll() public {
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit ApprovalForAll(alice, bob, true);
+        token.setApprovalForAll(bob, true);
+
+        assertTrue(token.isApprovedForAll(alice, bob));
+    }
+
+    function test_SetApprovalForAll_Revoke() public {
+        vm.startPrank(alice);
+        token.setApprovalForAll(bob, true);
+        token.setApprovalForAll(bob, false);
+        vm.stopPrank();
+
+        assertFalse(token.isApprovedForAll(alice, bob));
+    }
+
+    function test_Fuzz_SetApprovalForAll(address operator, bool approved) public {
+        vm.assume(operator != address(0));
+
+        vm.prank(alice);
+        token.setApprovalForAll(operator, approved);
+
+        assertEq(token.isApprovedForAll(alice, operator), approved);
+    }
+
+    function test_RevertWhen_SetApprovalForAllZeroAddress() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721InvalidOperator.selector, address(0)));
+        token.setApprovalForAll(address(0), true);
+    }
+
+    // ============================================
+    // Operator Transfer Tests
+    // ============================================
+
+    function test_OperatorCanTransfer() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.setApprovalForAll(bob, true);
+
+        vm.prank(bob);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, charlie, 1);
+        token.transferFrom(alice, charlie, 1);
+
+        assertEq(token.ownerOf(1), charlie);
+    }
+
+    function test_ApprovedCanTransfer() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.approve(bob, 1);
+
+        vm.prank(bob);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, charlie, 1);
+        token.transferFrom(alice, charlie, 1);
+
+        assertEq(token.ownerOf(1), charlie);
+    }
+
+    function test_ApprovalClearedOnTransfer() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.approve(bob, 1);
+        assertEq(token.getApproved(1), bob);
+
+        vm.prank(alice);
+        token.transferFrom(alice, charlie, 1);
+        assertEq(token.getApproved(1), address(0));
+    }
+
+    // ============================================
+    // Error Cases Tests
+    // ============================================
+
+    function test_RevertWhen_BalanceOfZeroAddress() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721InvalidOwner.selector, address(0)));
+        token.balanceOf(address(0));
+    }
+
+    function test_RevertWhen_OwnerOfNonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721NonexistentToken.selector, 1));
+        token.ownerOf(1);
+    }
+
+    function test_RevertWhen_GetApprovedNonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721NonexistentToken.selector, 1));
+        token.getApproved(1);
+    }
+
+    function test_RevertWhen_TokenURINonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(ERC721Facet.ERC721NonexistentToken.selector, 1));
+        token.tokenURI(1);
+    }
+
+    // ============================================
+    // Integration Tests
+    // ============================================
+
+    function test_MintTransferBurn_Flow() public {
+        token.mint(alice, 1);
+        assertEq(token.ownerOf(1), alice);
+
+        vm.prank(alice);
+        token.transferFrom(alice, bob, 1);
+        assertEq(token.ownerOf(1), bob);
+
+        vm.prank(bob);
+        token.burn(1);
+
+        vm.expectRevert();
+        token.ownerOf(1);
+    }
+
+    function test_ApproveTransferFromBurn_Flow() public {
+        token.mint(alice, 1);
+
+        vm.prank(alice);
+        token.approve(bob, 1);
+
+        vm.prank(bob);
+        token.transferFrom(alice, charlie, 1);
+        assertEq(token.ownerOf(1), charlie);
+
+        vm.prank(charlie);
+        token.burn(1);
+
+        vm.expectRevert();
+        token.ownerOf(1);
+    }
+}
diff --git a/test/ERC721/LibERC721.t.sol b/test/ERC721/LibERC721.t.sol
new file mode 100644
index 00000000..9d85b2e1
--- /dev/null
+++ b/test/ERC721/LibERC721.t.sol
@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+import {Test} from "forge-std/Test.sol";
+import {LibERC721Harness} from "./harnesses/LibERC721Harness.sol";
+import {LibERC721} from "../../src/token/ERC721/ERC721/LibERC721.sol";
+
+contract LibERC721Test is Test {
+    LibERC721Harness public harness;
+
+    address public alice;
+    address public bob;
+    address public charlie;
+
+    string constant TOKEN_NAME = "Test NFT";
+    string constant TOKEN_SYMBOL = "TNFT";
+    string constant BASE_URI = "https://api.example.com/metadata/";
+
+    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
+    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
+    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
+
+    function setUp() public {
+        alice = makeAddr("alice");
+        bob = makeAddr("bob");
+        charlie = makeAddr("charlie");
+
+        harness = new LibERC721Harness();
+        harness.initialize(TOKEN_NAME, TOKEN_SYMBOL, BASE_URI);
+    }
+
+    // ============================================
+    // Metadata Tests
+    // ============================================
+
+    function test_Name() public view {
+        assertEq(harness.name(), TOKEN_NAME);
+    }
+
+    function test_Symbol() public view {
+        assertEq(harness.symbol(), TOKEN_SYMBOL);
+    }
+
+    function test_BaseURI() public view {
+        assertEq(harness.baseURI(), BASE_URI);
+    }
+
+    function test_InitialBalance() public view {
+        assertEq(harness.balanceOf(alice), 0);
+    }
+
+    // ============================================
+    // Mint Tests
+    // ============================================
+
+    function test_Mint() public {
+        uint256 tokenId = 1;
+
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(address(0), alice, tokenId);
+        harness.mint(alice, tokenId);
+
+        assertEq(harness.ownerOf(tokenId), alice);
+        assertEq(harness.balanceOf(alice), 1);
+    }
+
+    function test_Mint_Multiple() public {
+        harness.mint(alice, 1);
+        harness.mint(alice, 2);
+        harness.mint(bob, 3);
+
+        assertEq(harness.ownerOf(1), alice);
+        assertEq(harness.ownerOf(2), alice);
+        assertEq(harness.ownerOf(3), bob);
+        assertEq(harness.balanceOf(alice), 2);
+        assertEq(harness.balanceOf(bob), 1);
+    }
+
+    function testFuzz_Mint(address to, uint256 tokenId) public {
+        vm.assume(to != address(0));
+        vm.assume(tokenId != 0);
+
+        harness.mint(to, tokenId);
+
+        assertEq(harness.ownerOf(tokenId), to);
+        assertEq(harness.balanceOf(to), 1);
+    }
+
+    function test_RevertWhen_MintToZeroAddress() public {
+        vm.expectRevert(abi.encodeWithSelector(LibERC721.ERC721InvalidReceiver.selector, address(0)));
+        harness.mint(address(0), 1);
+    }
+
+    function test_RevertWhen_MintExistingToken() public {
+        harness.mint(alice, 1);
+
+        vm.expectRevert(abi.encodeWithSelector(LibERC721.ERC721InvalidSender.selector, address(0)));
+        harness.mint(bob, 1);
+    }
+
+    // ============================================
+    // Burn Tests
+    // ============================================
+
+    function test_Burn() public {
+        uint256 tokenId = 1;
+
+        harness.mint(alice, tokenId);
+        assertEq(harness.ownerOf(tokenId), alice);
+        assertEq(harness.balanceOf(alice), 1);
+
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, address(0), tokenId);
+        harness.burn(tokenId);
+
+        assertEq(harness.balanceOf(alice), 0);
+    }
+
+    function test_Burn_EntireBalance() public {
+        harness.mint(alice, 1);
+        harness.mint(alice, 2);
+        harness.mint(alice, 3);
+
+        assertEq(harness.balanceOf(alice), 3);
+
+        harness.burn(1);
+        harness.burn(2);
+        harness.burn(3);
+
+        assertEq(harness.balanceOf(alice), 0);
+    }
+
+    function testFuzz_Burn(uint256 tokenId) public {
+        vm.assume(tokenId != 0);
+
+        harness.mint(alice, tokenId);
+        harness.burn(tokenId);
+
+        assertEq(harness.balanceOf(alice), 0);
+    }
+
+    function test_RevertWhen_BurnNonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(LibERC721.ERC721NonexistentToken.selector, 1));
+        harness.burn(1);
+    }
+
+    // ============================================
+    // Gas Benchmark Tests
+    // ============================================
+
+    function test_GasBenchmark_Mint() public {
+        uint256 gasStart = gasleft();
+        harness.mint(alice, 1);
+        uint256 gasUsed = gasStart - gasleft();
+
+        // Mint should use less than 100k gas
+        assertLt(gasUsed, 100_000);
+    }
+
+    function test_GasBenchmark_Burn() public {
+        harness.mint(alice, 1);
+
+        uint256 gasStart = gasleft();
+        harness.burn(1);
+        uint256 gasUsed = gasStart - gasleft();
+
+        // Burn should use less than 50k gas
+        assertLt(gasUsed, 50_000);
+    }
+
+    function test_GasBenchmark_MintMultiple() public {
+        uint256 gasStart = gasleft();
+
+        for (uint256 i = 1; i <= 10; i++) {
+            harness.mint(alice, i);
+        }
+
+        uint256 gasUsed = gasStart - gasleft();
+
+        // 10 mints should use less than 1M gas
+        assertLt(gasUsed, 1_000_000);
+    }
+
+    function test_GasBenchmark_BurnMultiple() public {
+        // Mint 10 tokens first
+        for (uint256 i = 1; i <= 10; i++) {
+            harness.mint(alice, i);
+        }
+
+        uint256 gasStart = gasleft();
+
+        for (uint256 i = 1; i <= 10; i++) {
+            harness.burn(i);
+        }
+
+        uint256 gasUsed = gasStart - gasleft();
+
+        // 10 burns should use less than 500k gas
+        assertLt(gasUsed, 500_000);
+    }
+
+    // ============================================
+    // Integration Tests
+    // ============================================
+
+    function test_MintBurn_Flow() public {
+        harness.mint(alice, 1);
+        assertEq(harness.ownerOf(1), alice);
+        assertEq(harness.balanceOf(alice), 1);
+
+        harness.burn(1);
+        assertEq(harness.balanceOf(alice), 0);
+    }
+
+    function test_MintMultipleBurn_Flow() public {
+        // Mint multiple tokens
+        harness.mint(alice, 1);
+        harness.mint(alice, 2);
+        harness.mint(bob, 3);
+
+        assertEq(harness.balanceOf(alice), 2);
+        assertEq(harness.balanceOf(bob), 1);
+
+        // Burn some tokens
+        harness.burn(1);
+        harness.burn(3);
+
+        assertEq(harness.balanceOf(alice), 1);
+        assertEq(harness.balanceOf(bob), 0);
+        assertEq(harness.ownerOf(2), alice);
+    }
+}
diff --git a/test/ERC721/LibERC721Enumerable.t.sol b/test/ERC721/LibERC721Enumerable.t.sol
new file mode 100644
index 00000000..4c479fc3
--- /dev/null
+++ b/test/ERC721/LibERC721Enumerable.t.sol
@@ -0,0 +1,358 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+import {Test} from "forge-std/Test.sol";
+import {LibERC721EnumerableHarness} from "./harnesses/LibERC721EnumerableHarness.sol";
+import {LibERC721 as LibERC721Enumerable} from "../../src/token/ERC721/ERC721Enumerable/LibERC721Enumerable.sol";
+
+contract LibERC721EnumerableTest is Test {
+    LibERC721EnumerableHarness public harness;
+
+    address public alice;
+    address public bob;
+    address public charlie;
+
+    string constant TOKEN_NAME = "Test Enumerable NFT";
+    string constant TOKEN_SYMBOL = "TENFT";
+    string constant BASE_URI = "https://api.example.com/metadata/";
+
+    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
+    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
+    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
+
+    function setUp() public {
+        alice = makeAddr("alice");
+        bob = makeAddr("bob");
+        charlie = makeAddr("charlie");
+
+        harness = new LibERC721EnumerableHarness();
+        harness.initialize(TOKEN_NAME, TOKEN_SYMBOL, BASE_URI);
+    }
+
+    // ============================================
+    // Metadata Tests
+    // ============================================
+
+    function test_Name() public view {
+        assertEq(harness.name(), TOKEN_NAME);
+    }
+
+    function test_Symbol() public view {
+        assertEq(harness.symbol(), TOKEN_SYMBOL);
+    }
+
+    function test_BaseURI() public view {
+        assertEq(harness.baseURI(), BASE_URI);
+    }
+
+    function test_InitialBalance() public view {
+        assertEq(harness.balanceOf(alice), 0);
+    }
+
+    function test_InitialTotalSupply() public view {
+        assertEq(harness.totalSupply(), 0);
+    }
+
+    // ============================================
+    // Mint Tests
+    // ============================================
+
+    function test_Mint() public {
+        uint256 tokenId = 1;
+
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(address(0), alice, tokenId);
+        harness.mint(alice, tokenId);
+
+        assertEq(harness.ownerOf(tokenId), alice);
+        assertEq(harness.balanceOf(alice), 1);
+        assertEq(harness.totalSupply(), 1);
+        assertEq(harness.tokenOfOwnerByIndex(alice, 0), tokenId);
+        assertEq(harness.tokenByIndex(0), tokenId);
+    }
+
+    function test_Mint_Multiple() public {
+        harness.mint(alice, 1);
+        harness.mint(alice, 2);
+        harness.mint(bob, 3);
+
+        assertEq(harness.ownerOf(1), alice);
+        assertEq(harness.ownerOf(2), alice);
+        assertEq(harness.ownerOf(3), bob);
+        assertEq(harness.balanceOf(alice), 2);
+        assertEq(harness.balanceOf(bob), 1);
+        assertEq(harness.totalSupply(), 3);
+
+        // Check enumeration
+        assertEq(harness.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(harness.tokenOfOwnerByIndex(alice, 1), 2);
+        assertEq(harness.tokenOfOwnerByIndex(bob, 0), 3);
+
+        assertEq(harness.tokenByIndex(0), 1);
+        assertEq(harness.tokenByIndex(1), 2);
+        assertEq(harness.tokenByIndex(2), 3);
+    }
+
+    function testFuzz_Mint(address to, uint256 tokenId) public {
+        vm.assume(to != address(0));
+        vm.assume(tokenId != 0);
+
+        harness.mint(to, tokenId);
+
+        assertEq(harness.ownerOf(tokenId), to);
+        assertEq(harness.balanceOf(to), 1);
+        assertEq(harness.totalSupply(), 1);
+    }
+
+    function test_RevertWhen_MintToZeroAddress() public {
+        vm.expectRevert(abi.encodeWithSelector(LibERC721Enumerable.ERC721InvalidReceiver.selector, address(0)));
+        harness.mint(address(0), 1);
+    }
+
+    function test_RevertWhen_MintExistingToken() public {
+        harness.mint(alice, 1);
+
+        vm.expectRevert(abi.encodeWithSelector(LibERC721Enumerable.ERC721InvalidSender.selector, address(0)));
+        harness.mint(bob, 1);
+    }
+
+    // ============================================
+    // Burn Tests
+    // ============================================
+
+    function test_Burn() public {
+        uint256 tokenId = 1;
+
+        harness.mint(alice, tokenId);
+        assertEq(harness.ownerOf(tokenId), alice);
+        assertEq(harness.balanceOf(alice), 1);
+        assertEq(harness.totalSupply(), 1);
+
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit Transfer(alice, address(0), tokenId);
+        harness.burn(tokenId, alice);
+
+        assertEq(harness.balanceOf(alice), 0);
+        assertEq(harness.totalSupply(), 0);
+    }
+
+    function test_Burn_EntireBalance() public {
+        harness.mint(alice, 1);
+        harness.mint(alice, 2);
+        harness.mint(alice, 3);
+
+        assertEq(harness.balanceOf(alice), 3);
+        assertEq(harness.totalSupply(), 3);
+
+        vm.startPrank(alice);
+        harness.burn(1, alice);
+        harness.burn(2, alice);
+        harness.burn(3, alice);
+        vm.stopPrank();
+
+        assertEq(harness.balanceOf(alice), 0);
+        assertEq(harness.totalSupply(), 0);
+    }
+
+    function testFuzz_Burn(uint256 tokenId) public {
+        vm.assume(tokenId != 0);
+
+        harness.mint(alice, tokenId);
+        vm.prank(alice);
+        harness.burn(tokenId, alice);
+
+        assertEq(harness.balanceOf(alice), 0);
+        assertEq(harness.totalSupply(), 0);
+    }
+
+    function test_RevertWhen_BurnNonExistentToken() public {
+        vm.expectRevert(abi.encodeWithSelector(LibERC721Enumerable.ERC721NonexistentToken.selector, 1));
+        harness.burn(1, alice);
+    }
+
+    function test_RevertWhen_BurnInsufficientApproval() public {
+        harness.mint(alice, 1);
+
+        vm.prank(bob);
+        vm.expectRevert(abi.encodeWithSelector(LibERC721Enumerable.ERC721InsufficientApproval.selector, bob, 1));
+        harness.burn(1, bob);
+    }
+
+    // ============================================
+    // Enumeration Tests
+    // ============================================
+
+    function test_TokenOfOwnerByIndex() public {
+        harness.mint(alice, 1);
+        harness.mint(alice, 2);
+        harness.mint(bob, 3);
+
+        assertEq(harness.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(harness.tokenOfOwnerByIndex(alice, 1), 2);
+        assertEq(harness.tokenOfOwnerByIndex(bob, 0), 3);
+    }
+
+    function test_TokenByIndex() public {
+        harness.mint(alice, 1);
+        harness.mint(bob, 2);
+        harness.mint(alice, 3);
+
+        assertEq(harness.tokenByIndex(0), 1);
+        assertEq(harness.tokenByIndex(1), 2);
+        assertEq(harness.tokenByIndex(2), 3);
+    }
+
+    function test_TotalSupply() public {
+        assertEq(harness.totalSupply(), 0);
+
+        harness.mint(alice, 1);
+        assertEq(harness.totalSupply(), 1);
+
+        harness.mint(bob, 2);
+        assertEq(harness.totalSupply(), 2);
+
+        vm.prank(alice);
+        harness.burn(1, alice);
+        assertEq(harness.totalSupply(), 1);
+    }
+
+    // ============================================
+    // Gas Benchmark Tests
+    // ============================================
+
+    function test_GasBenchmark_Mint() public {
+        uint256 gasStart = gasleft();
+        harness.mint(alice, 1);
+        uint256 gasUsed = gasStart - gasleft();
+
+        // Mint should use less than 150k gas (includes enumeration)
+        assertLt(gasUsed, 150_000);
+    }
+
+    function test_GasBenchmark_Burn() public {
+        harness.mint(alice, 1);
+
+        uint256 gasStart = gasleft();
+        vm.prank(alice);
+        harness.burn(1, alice);
+        uint256 gasUsed = gasStart - gasleft();
+
+        // Burn should use less than 100k gas (includes enumeration)
+        assertLt(gasUsed, 100_000);
+    }
+
+    function test_GasBenchmark_MintMultiple() public {
+        uint256 gasStart = gasleft();
+
+        for (uint256 i = 1; i <= 10; i++) {
+            harness.mint(alice, i);
+        }
+
+        uint256 gasUsed = gasStart - gasleft();
+
+        // 10 mints should use less than 1.5M gas
+        assertLt(gasUsed, 1_500_000);
+    }
+
+    function test_GasBenchmark_BurnMultiple() public {
+        // Mint 10 tokens first
+        for (uint256 i = 1; i <= 10; i++) {
+            harness.mint(alice, i);
+        }
+
+        uint256 gasStart = gasleft();
+
+        vm.startPrank(alice);
+        for (uint256 i = 1; i <= 10; i++) {
+            harness.burn(i, alice);
+        }
+        vm.stopPrank();
+
+        uint256 gasUsed = gasStart - gasleft();
+
+        // 10 burns should use less than 1M gas
+        assertLt(gasUsed, 1_000_000);
+    }
+
+    function test_GasBenchmark_Enumeration() public {
+        // Mint 100 tokens for enumeration testing
+        for (uint256 i = 1; i <= 100; i++) {
+            harness.mint(alice, i);
+        }
+
+        uint256 gasStart = gasleft();
+
+        // Test tokenOfOwnerByIndex
+        for (uint256 i = 0; i < 100; i++) {
+            harness.tokenOfOwnerByIndex(alice, i);
+        }
+
+        uint256 gasUsed = gasStart - gasleft();
+
+        // 100 tokenOfOwnerByIndex calls should use less than 500k gas
+        assertLt(gasUsed, 500_000);
+    }
+
+    // ============================================
+    // Integration Tests
+    // ============================================
+
+    function test_MintBurn_Flow() public {
+        harness.mint(alice, 1);
+        assertEq(harness.ownerOf(1), alice);
+        assertEq(harness.balanceOf(alice), 1);
+        assertEq(harness.totalSupply(), 1);
+
+        vm.prank(alice);
+        harness.burn(1, alice);
+        assertEq(harness.balanceOf(alice), 0);
+        assertEq(harness.totalSupply(), 0);
+    }
+
+    function test_MintMultipleBurn_Flow() public {
+        // Mint multiple tokens
+        harness.mint(alice, 1);
+        harness.mint(alice, 2);
+        harness.mint(bob, 3);
+
+        assertEq(harness.balanceOf(alice), 2);
+        assertEq(harness.balanceOf(bob), 1);
+        assertEq(harness.totalSupply(), 3);
+
+        // Burn some tokens
+        vm.startPrank(alice);
+        harness.burn(1, alice);
+        vm.stopPrank();
+
+        vm.prank(bob);
+        harness.burn(3, bob);
+
+        assertEq(harness.balanceOf(alice), 1);
+        assertEq(harness.balanceOf(bob), 0);
+        assertEq(harness.ownerOf(2), alice);
+        assertEq(harness.totalSupply(), 1);
+    }
+
+    function test_EnumerationAfterBurn() public {
+        // Mint tokens
+        harness.mint(alice, 1);
+        harness.mint(alice, 2);
+        harness.mint(alice, 3);
+
+        // Verify initial enumeration
+        assertEq(harness.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(harness.tokenOfOwnerByIndex(alice, 1), 2);
+        assertEq(harness.tokenOfOwnerByIndex(alice, 2), 3);
+
+        // Burn middle token
+        vm.prank(alice);
+        harness.burn(2, alice);
+
+        // Verify enumeration after burn
+        assertEq(harness.tokenOfOwnerByIndex(alice, 0), 1);
+        assertEq(harness.tokenOfOwnerByIndex(alice, 1), 3);
+        assertEq(harness.balanceOf(alice), 2);
+        assertEq(harness.totalSupply(), 2);
+    }
+}
diff --git a/test/ERC721/harnesses/ERC721EnumerableFacetHarness.sol b/test/ERC721/harnesses/ERC721EnumerableFacetHarness.sol
new file mode 100644
index 00000000..20f54f8b
--- /dev/null
+++ b/test/ERC721/harnesses/ERC721EnumerableFacetHarness.sol
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+import {ERC721EnumerableFacet} from "../../../src/token/ERC721/ERC721Enumerable/ERC721EnumerableFacet.sol";
+
+/// @title ERC721EnumerableFacetHarness
+/// @notice Test harness for ERC721EnumerableFacet that adds initialization and minting for testing
+contract ERC721EnumerableFacetHarness is ERC721EnumerableFacet {
+    /// @notice Initialize the ERC721Enumerable token storage
+    /// @dev Only used for testing - production diamonds should initialize in constructor
+    function initialize(string memory _name, string memory _symbol, string memory _baseURI) external {
+        ERC721EnumerableStorage storage s = getStorage();
+        s.name = _name;
+        s.symbol = _symbol;
+        s.baseURI = _baseURI;
+    }
+
+    /// @notice Mint a token to an address
+    /// @dev Only used for testing - implements minimal mint for harnessing
+    function mint(address _to, uint256 _tokenId) external {
+        ERC721EnumerableStorage storage s = getStorage();
+        if (_to == address(0)) {
+            revert ERC721InvalidReceiver(address(0));
+        }
+        if (s.ownerOf[_tokenId] != address(0)) {
+            revert ERC721InvalidSender(address(0));
+        }
+
+        s.ownerOf[_tokenId] = _to;
+        s.ownedTokensIndexOf[_tokenId] = s.ownedTokensOf[_to].length;
+        s.ownedTokensOf[_to].push(_tokenId);
+        s.allTokensIndexOf[_tokenId] = s.allTokens.length;
+        s.allTokens.push(_tokenId);
+        emit Transfer(address(0), _to, _tokenId);
+    }
+
+    /// @notice Burn a token
+    /// @dev Only used for testing - implements minimal burn for harnessing
+    function burn(uint256 _tokenId) external {
+        ERC721EnumerableStorage storage s = getStorage();
+        address owner = s.ownerOf[_tokenId];
+        if (owner == address(0)) {
+            revert ERC721NonexistentToken(_tokenId);
+        }
+
+        delete s.ownerOf[_tokenId];
+        delete s.approved[_tokenId];
+
+        uint256 tokenIndex = s.ownedTokensIndexOf[_tokenId];
+        uint256 lastTokenIndex = s.ownedTokensOf[owner].length - 1;
+        if (tokenIndex != lastTokenIndex) {
+            uint256 lastTokenId = s.ownedTokensOf[owner][lastTokenIndex];
+            s.ownedTokensOf[owner][tokenIndex] = lastTokenId;
+            s.ownedTokensIndexOf[lastTokenId] = tokenIndex;
+        }
+        s.ownedTokensOf[owner].pop();
+
+        tokenIndex = s.allTokensIndexOf[_tokenId];
+        lastTokenIndex = s.allTokens.length - 1;
+        if (tokenIndex != lastTokenIndex) {
+            uint256 lastTokenId = s.allTokens[lastTokenIndex];
+            s.allTokens[tokenIndex] = lastTokenId;
+            s.allTokensIndexOf[lastTokenId] = tokenIndex;
+        }
+        s.allTokens.pop();
+        emit Transfer(owner, address(0), _tokenId);
+    }
+}
diff --git a/test/ERC721/harnesses/ERC721FacetHarness.sol b/test/ERC721/harnesses/ERC721FacetHarness.sol
new file mode 100644
index 00000000..6075b9ca
--- /dev/null
+++ b/test/ERC721/harnesses/ERC721FacetHarness.sol
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+import {ERC721Facet} from "../../../src/token/ERC721/ERC721/ERC721Facet.sol";
+
+/// @title ERC721FacetHarness
+/// @notice Test harness for ERC721Facet that adds initialization and minting for testing
+contract ERC721FacetHarness is ERC721Facet {
+    /// @notice Initialize the ERC721 token storage
+    /// @dev Only used for testing - production diamonds should initialize in constructor
+    function initialize(string memory _name, string memory _symbol, string memory _baseURI) external {
+        ERC721Storage storage s = getStorage();
+        s.name = _name;
+        s.symbol = _symbol;
+        s.baseURI = _baseURI;
+    }
+
+    /// @notice Mint tokens to an address
+    /// @dev Only used for testing - exposes internal mint functionality
+    function mint(address _to, uint256 _tokenId) external {
+        ERC721Storage storage s = getStorage();
+        if (_to == address(0)) {
+            revert ERC721InvalidReceiver(address(0));
+        }
+        if (s.ownerOf[_tokenId] != address(0)) {
+            revert ERC721InvalidSender(address(0));
+        }
+        s.ownerOf[_tokenId] = _to;
+        unchecked {
+            s.balanceOf[_to]++;
+        }
+        emit Transfer(address(0), _to, _tokenId);
+    }
+
+    /// @notice Burn a token
+    /// @dev Only used for testing - exposes internal burn functionality
+    function burn(uint256 _tokenId) external {
+        ERC721Storage storage s = getStorage();
+        address owner = s.ownerOf[_tokenId];
+        if (owner == address(0)) {
+            revert ERC721NonexistentToken(_tokenId);
+        }
+        delete s.ownerOf[_tokenId];
+        delete s.approved[_tokenId];
+        unchecked {
+            s.balanceOf[owner]--;
+        }
+        emit Transfer(owner, address(0), _tokenId);
+    }
+}
diff --git a/test/ERC721/harnesses/LibERC721EnumerableHarness.sol b/test/ERC721/harnesses/LibERC721EnumerableHarness.sol
new file mode 100644
index 00000000..10cd5427
--- /dev/null
+++ b/test/ERC721/harnesses/LibERC721EnumerableHarness.sol
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+import {LibERC721 as LibERC721Enumerable} from "../../../src/token/ERC721/ERC721Enumerable/LibERC721Enumerable.sol";
+
+/// @title LibERC721EnumerableHarness
+/// @notice Test harness that exposes LibERC721Enumerable's internal functions as external
+/// @dev Required for testing since LibERC721Enumerable only has internal functions
+contract LibERC721EnumerableHarness {
+    /// @notice Initialize the ERC721Enumerable token storage
+    /// @dev Only used for testing
+    function initialize(string memory _name, string memory _symbol, string memory _baseURI) external {
+        LibERC721Enumerable.ERC721EnumerableStorage storage s = LibERC721Enumerable.getStorage();
+        s.name = _name;
+        s.symbol = _symbol;
+        s.baseURI = _baseURI;
+    }
+
+    /// @notice Exposes LibERC721Enumerable.mint as an external function
+    /// @dev Only used for testing
+    function mint(address _to, uint256 _tokenId) external {
+        LibERC721Enumerable.mint(_to, _tokenId);
+    }
+
+    /// @notice Exposes LibERC721Enumerable.burn as an external function
+    function burn(uint256 _tokenId, address _sender) external {
+        LibERC721Enumerable.burn(_tokenId, _sender);
+    }
+
+    /// @notice Get storage values for testing
+    function name() external view returns (string memory) {
+        return LibERC721Enumerable.getStorage().name;
+    }
+
+    function symbol() external view returns (string memory) {
+        return LibERC721Enumerable.getStorage().symbol;
+    }
+
+    function baseURI() external view returns (string memory) {
+        return LibERC721Enumerable.getStorage().baseURI;
+    }
+
+    function ownerOf(uint256 _tokenId) external view returns (address) {
+        return LibERC721Enumerable.getStorage().ownerOf[_tokenId];
+    }
+
+    function balanceOf(address _owner) external view returns (uint256) {
+        return LibERC721Enumerable.getStorage().ownedTokensOf[_owner].length;
+    }
+
+    function getApproved(uint256 _tokenId) external view returns (address) {
+        return LibERC721Enumerable.getStorage().approved[_tokenId];
+    }
+
+    function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
+        return LibERC721Enumerable.getStorage().isApprovedForAll[_owner][_operator];
+    }
+
+    function totalSupply() external view returns (uint256) {
+        return LibERC721Enumerable.getStorage().allTokens.length;
+    }
+
+    function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
+        return LibERC721Enumerable.getStorage().ownedTokensOf[_owner][_index];
+    }
+
+    function tokenByIndex(uint256 _index) external view returns (uint256) {
+        return LibERC721Enumerable.getStorage().allTokens[_index];
+    }
+}
diff --git a/test/ERC721/harnesses/LibERC721Harness.sol b/test/ERC721/harnesses/LibERC721Harness.sol
new file mode 100644
index 00000000..d51edf58
--- /dev/null
+++ b/test/ERC721/harnesses/LibERC721Harness.sol
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+import {LibERC721} from "../../../src/token/ERC721/ERC721/LibERC721.sol";
+
+/// @title LibERC721Harness
+/// @notice Test harness that exposes LibERC721's internal functions as external
+/// @dev Required for testing since LibERC721 only has internal functions
+contract LibERC721Harness {
+    /// @notice Initialize the ERC721 token storage
+    /// @dev Only used for testing
+    function initialize(string memory _name, string memory _symbol, string memory _baseURI) external {
+        LibERC721.ERC721Storage storage s = LibERC721.getStorage();
+        s.name = _name;
+        s.symbol = _symbol;
+        s.baseURI = _baseURI;
+    }
+
+    /// @notice Exposes LibERC721.mint as an external function
+    function mint(address _to, uint256 _tokenId) external {
+        LibERC721.mint(_to, _tokenId);
+    }
+
+    /// @notice Exposes LibERC721.burn as an external function
+    function burn(uint256 _tokenId) external {
+        LibERC721.burn(_tokenId);
+    }
+
+    /// @notice Get storage values for testing
+    function name() external view returns (string memory) {
+        return LibERC721.getStorage().name;
+    }
+
+    function symbol() external view returns (string memory) {
+        return LibERC721.getStorage().symbol;
+    }
+
+    function baseURI() external view returns (string memory) {
+        return LibERC721.getStorage().baseURI;
+    }
+
+    function ownerOf(uint256 _tokenId) external view returns (address) {
+        return LibERC721.getStorage().ownerOf[_tokenId];
+    }
+
+    function balanceOf(address _owner) external view returns (uint256) {
+        return LibERC721.getStorage().balanceOf[_owner];
+    }
+
+    function getApproved(uint256 _tokenId) external view returns (address) {
+        return LibERC721.getStorage().approved[_tokenId];
+    }
+
+    function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
+        return LibERC721.getStorage().isApprovedForAll[_owner][_operator];
+    }
+}