diff --git a/CHANGELOG.md b/CHANGELOG.md
index a8d1f0e..79845fe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.7]
+
+### Added
+
+- JSON textarea editor in demo page replacing read-only data display
+- Radio button selection for three example datasets (User Profile, E-commerce Data, API Response) and custom JSON input
+- Consolidated path validation tests into `test_normalize_path.py` with new test cases for complex keys and None value handling
+
+
+### Fixed
+
+- Fixed `normalize_path()` converting all list path keys to strings, now preserves integer and other key types.
+
 ## [1.1.6]
 
 ### Added
@@ -120,6 +133,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Immutable container protection (tuples cannot be modified)
 - Safe list deletion (requires explicit `allow_list_mutation=True` flag)
 
+[1.1.7]: https://github.com/ysskrishna/nestedutils/compare/v1.1.6...v1.1.7
 [1.1.6]: https://github.com/ysskrishna/nestedutils/compare/v1.1.5...v1.1.6
 [1.1.5]: https://github.com/ysskrishna/nestedutils/compare/v1.1.4...v1.1.5
 [1.1.4]: https://github.com/ysskrishna/nestedutils/compare/v1.1.3...v1.1.4
diff --git a/docs/demo.md b/docs/demo.md
index 2ed8b50..751b0ee 100644
--- a/docs/demo.md
+++ b/docs/demo.md
@@ -29,22 +29,38 @@ Try the `nestedutils` library directly in your browser! This page uses [Pyodide]
 
 <div id="test-interface" style="display: none;">
   <div class="test-section">
-    <h3>Current Data Structure</h3>
-    <p style="color: #666; font-size: 0.9em; margin-bottom: 10px;">This is your working data structure. All operations will modify this structure.</p>
-    <div id="data-display" style="padding: 15px; background: #f5f5f5; border-radius: 4px; font-family: monospace; white-space: pre-wrap; max-height: 300px; overflow-y: auto; border: 1px solid #e0e0e0;"></div>
-    <div style="margin-top: 10px; display: flex; gap: 10px;">
-      <button 
-        id="reset-btn" 
-        style="padding: 8px 16px; background: #757575; color: white; border: none; border-radius: 4px; cursor: pointer;"
-      >
-        Reset to Empty
-      </button>
-      <button 
-        id="load-example-btn" 
-        style="padding: 8px 16px; background: #1976d2; color: white; border: none; border-radius: 4px; cursor: pointer;"
-      >
-        Load Example Data
-      </button>
+    <h3>Data Source</h3>
+    <p style="color: #666; font-size: 0.9em; margin-bottom: 15px;">Select an example or edit the JSON directly. Valid JSON is automatically applied when you stop typing.</p>
+    
+    <!-- Horizontal Radio Buttons -->
+    <div style="display: flex; gap: 20px; margin-bottom: 20px; flex-wrap: wrap; align-items: center;">
+      <label style="display: flex; align-items: center; gap: 6px; cursor: pointer; padding: 6px 0;" onmouseover="this.style.opacity='0.7'" onmouseout="this.style.opacity='1'">
+        <input type="radio" name="data-source" value="example1" id="radio-example1" style="cursor: pointer;" />
+        <span>Example 1: User Profile</span>
+      </label>
+      <label style="display: flex; align-items: center; gap: 6px; cursor: pointer; padding: 6px 0;" onmouseover="this.style.opacity='0.7'" onmouseout="this.style.opacity='1'">
+        <input type="radio" name="data-source" value="example2" id="radio-example2" style="cursor: pointer;" />
+        <span>Example 2: E-commerce Data</span>
+      </label>
+      <label style="display: flex; align-items: center; gap: 6px; cursor: pointer; padding: 6px 0;" onmouseover="this.style.opacity='0.7'" onmouseout="this.style.opacity='1'">
+        <input type="radio" name="data-source" value="example3" id="radio-example3" style="cursor: pointer;" />
+        <span>Example 3: API Response</span>
+      </label>
+      <label style="display: flex; align-items: center; gap: 6px; cursor: pointer; padding: 6px 0;" onmouseover="this.style.opacity='0.7'" onmouseout="this.style.opacity='1'">
+        <input type="radio" name="data-source" value="custom" id="radio-custom" style="cursor: pointer;" />
+        <span>Custom JSON</span>
+      </label>
+    </div>
+    
+    <!-- JSON Textarea -->
+    <div style="position: relative;">
+      <div id="json-status" style="position: absolute; top: 10px; right: 10px; font-size: 0.85em; font-weight: 500; z-index: 1;"></div>
+      <textarea 
+        id="custom-json-input" 
+        placeholder='Enter valid JSON here, e.g., {"key": "value"}'
+        style="width: 100%; min-height: 300px; padding: 12px; border: 1px solid #ccc; border-radius: 4px; font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.9em; resize: vertical; line-height: 1.5; tab-size: 2;"
+      ></textarea>
+      <div id="json-error" style="margin-top: 8px; font-size: 0.85em; min-height: 20px; font-family: monospace;"></div>
     </div>
   </div>
 
@@ -216,16 +232,37 @@ Try the `nestedutils` library directly in your browser! This page uses [Pyodide]
     cursor: pointer;
   }
   
-  select:focus, input:focus {
+  select:focus, input:focus, textarea:focus {
     outline: 2px solid #1976d2;
     outline-offset: 2px;
   }
+  
+  #json-error {
+    font-family: monospace;
+    font-size: 0.85em;
+  }
+  
+  #json-status {
+    font-weight: 500;
+  }
+  
+  textarea {
+    line-height: 1.5;
+  }
+  
+  @media (max-width: 768px) {
+    .test-section > div[style*="display: flex"] {
+      flex-direction: column !important;
+    }
+  }
 </style>
 
 <script src="https://cdn.jsdelivr.net/pyodide/v0.24.1/full/pyodide.js"></script>
 
 <script type="text/javascript">
   let pyodide;
+  let appliedJsonString = ""; // Track the currently applied JSON
+  let autoApplyTimer = null; // Debounce timer for auto-apply
 
   async function main() {
     // Load Pyodide
@@ -270,7 +307,22 @@ Try the `nestedutils` library directly in your browser! This page uses [Pyodide]
     }
     
     // Initialize data structure display
-    updateDataDisplay();
+    updateDataDisplay(true); // Sync textarea on initial load
+    
+    // Set initial radio button state
+    document.getElementById("radio-custom").checked = true;
+    
+    // Initialize applied state
+    const initialJson = document.getElementById("custom-json-input").value.trim();
+    if (initialJson) {
+      try {
+        appliedJsonString = JSON.stringify(JSON.parse(initialJson));
+      } catch (e) {
+        appliedJsonString = "";
+      }
+    } else {
+      appliedJsonString = "{}";
+    }
     
     // Hide loading, show interface
     document.getElementById("pyodide-loading").style.display = "none";
@@ -280,47 +332,324 @@ Try the `nestedutils` library directly in your browser! This page uses [Pyodide]
     setupEventListeners();
   }
 
-  function updateDataDisplay() {
+  function updateDataDisplay(syncTextarea = false) {
+    // Sync JSON editor with current data structure when loading examples
+    if (syncTextarea) {
+      try {
+        const json = pyodide.runPython(`json.dumps(data, indent=2)`);
+        const jsonStr = json || "{}";
+        const customInput = document.getElementById("custom-json-input");
+        customInput.value = jsonStr;
+        // Update applied state to match current data
+        appliedJsonString = JSON.stringify(JSON.parse(jsonStr));
+        // Clear any error messages and update status
+        document.getElementById("json-error").textContent = "";
+        updateJsonStatus(true);
+      } catch (error) {
+        console.error("Error updating display:", error);
+      }
+    }
+  }
+  
+  // Check if there are unsaved changes (for auto-apply)
+  function hasUnsavedChanges() {
+    const jsonInput = document.getElementById("custom-json-input").value.trim();
+    
+    // Handle empty input
+    if (!jsonInput) {
+      // Empty input matches empty applied state or {}
+      return appliedJsonString !== "" && appliedJsonString !== "{}";
+    }
+    
+    // Handle empty object/array strings
+    if (jsonInput === "{}" || jsonInput === "[]") {
+      const normalized = jsonInput;
+      return normalized !== appliedJsonString;
+    }
+    
     try {
-      const json = pyodide.runPython(`json.dumps(data, indent=2)`);
-      document.getElementById("data-display").textContent = json || "{}";
+      // Normalize both for comparison (handles formatting differences)
+      const normalized = JSON.stringify(JSON.parse(jsonInput));
+      // Compare normalized strings
+      return normalized !== appliedJsonString;
+    } catch {
+      // If invalid JSON, consider it as having changes
+      return true;
+    }
+  }
+  
+  // Apply JSON function (auto-apply only)
+  function applyJsonData() {
+    const jsonInput = document.getElementById("custom-json-input").value.trim();
+    const errorDiv = document.getElementById("json-error");
+    
+    if (!jsonInput) {
+      updateJsonStatus(false, "Please enter JSON data");
+      errorDiv.textContent = "Please enter JSON data";
+      errorDiv.style.color = "#c62828";
+      return;
+    }
+    
+    // Validate JSON
+    let parsedData;
+    try {
+      parsedData = JSON.parse(jsonInput);
     } catch (error) {
-      document.getElementById("data-display").textContent = "Error displaying data";
+      updateJsonStatus(false, "Invalid JSON");
+      errorDiv.textContent = `Invalid JSON: ${error.message}`;
+      errorDiv.style.color = "#c62828";
+      return;
+    }
+    
+    // Validate that it's an object or array (not primitive)
+    if (typeof parsedData !== "object" || parsedData === null) {
+      updateJsonStatus(false, "Must be object or array");
+      errorDiv.textContent = "JSON must be an object {} or array []";
+      errorDiv.style.color = "#c62828";
+      return;
+    }
+    
+    // Set the data in Python
+    try {
+      const jsonStr = JSON.stringify(parsedData);
+      pyodide.runPython(`data = json.loads(${JSON.stringify(jsonStr)})`);
+      appliedJsonString = jsonStr; // Update applied state
+      clearResults();
+      updateJsonStatus(true, "✓ Applied");
+      errorDiv.textContent = "";
+      document.getElementById("radio-custom").checked = true;
+    } catch (error) {
+      updateJsonStatus(false, "Error applying");
+      errorDiv.textContent = `Error setting data: ${error.message}`;
+      errorDiv.style.color = "#c62828";
     }
   }
 
   function setupEventListeners() {
-    // Reset data
-    document.getElementById("reset-btn").addEventListener("click", () => {
-      pyodide.runPython(`data = {}`);
-      updateDataDisplay();
-      clearResults();
+    // Note: Removed "Reset to Empty" button - users can just clear the JSON editor or set it to {}
+    
+    // Radio button change handlers
+    const radioButtons = document.querySelectorAll('input[name="data-source"]');
+    radioButtons.forEach(radio => {
+      radio.addEventListener("change", (e) => {
+        const value = e.target.value;
+        if (value === "custom") {
+          // Don't auto-load, just switch to custom mode
+          return;
+        }
+        loadExampleData(value);
+      });
     });
     
-    // Load example data
-    document.getElementById("load-example-btn").addEventListener("click", () => {
-      pyodide.runPython(`
+    // Load example data function
+    function loadExampleData(exampleType) {
+      let exampleCode = "";
+      
+      switch(exampleType) {
+        case "example1":
+          // Example 1: User Profile
+          exampleCode = `
         data = {
           "user": {
             "name": "John Doe",
             "age": 30,
             "profile": {
               "email": "john@example.com",
-              "bio": "Software developer"
+                  "bio": "Software developer",
+                  "address": {
+                    "street": "123 Main St",
+                    "city": "San Francisco",
+                    "zip": "94102"
+                  }
+                },
+                "preferences": {
+                  "theme": "dark",
+                  "notifications": True,
+                  "language": "en"
             }
           },
           "items": [
             {"id": 1, "title": "First Item", "tags": ["python", "demo"]},
             {"id": 2, "title": "Second Item", "tags": ["javascript"]}
-          ],
-          "settings": {
-            "theme": "dark",
-            "notifications": True
+              ]
+            }
+          `;
+          break;
+        case "example2":
+          // Example 2: E-commerce Data
+          exampleCode = `
+            data = {
+              "store": {
+                "name": "TechShop",
+                "location": "New York"
+              },
+              "products": [
+                {
+                  "id": 101,
+                  "name": "Laptop",
+                  "price": 999.99,
+                  "inventory": {
+                    "stock": 45,
+                    "warehouse": "A1"
+                  },
+                  "reviews": [
+                    {"rating": 5, "comment": "Great product!"},
+                    {"rating": 4, "comment": "Good value"}
+                  ]
+                },
+                {
+                  "id": 102,
+                  "name": "Mouse",
+                  "price": 29.99,
+                  "inventory": {
+                    "stock": 120,
+                    "warehouse": "B2"
+                  },
+                  "reviews": []
+                }
+              ],
+              "orders": [
+                {
+                  "order_id": "ORD-001",
+                  "customer": "Alice",
+                  "items": ["101", "102"],
+                  "total": 1029.98
+                }
+              ]
+            }
+          `;
+          break;
+        case "example3":
+          // Example 3: API Response
+          exampleCode = `
+            data = {
+              "status": "success",
+              "data": {
+                "users": [
+                  {
+                    "id": 1,
+                    "username": "alice",
+                    "metadata": {
+                      "created_at": "2024-01-15",
+                      "last_login": "2024-12-01"
+                    },
+                    "roles": ["admin", "user"]
+                  },
+                  {
+                    "id": 2,
+                    "username": "bob",
+                    "metadata": {
+                      "created_at": "2024-02-20",
+                      "last_login": None
+                    },
+                    "roles": ["user"]
+                  }
+                ],
+                "pagination": {
+                  "page": 1,
+                  "per_page": 10,
+                  "total": 2
+                }
+              },
+              "errors": []
+            }
+          `;
+          break;
+      }
+      
+      if (exampleCode) {
+        pyodide.runPython(exampleCode);
+        updateDataDisplay(true); // Sync textarea when loading examples
+        clearResults();
+        updateJsonStatus(true, "✓ Example loaded");
+        // Check the corresponding radio button
+        document.getElementById(`radio-${exampleType}`).checked = true;
+        // Update applied state to match loaded example
+        const jsonInput = document.getElementById("custom-json-input").value.trim();
+        if (jsonInput) {
+          try {
+            appliedJsonString = JSON.stringify(JSON.parse(jsonInput));
+          } catch (e) {
+            appliedJsonString = "";
           }
         }
-      `);
-      updateDataDisplay();
-      clearResults();
+      }
+    }
+    
+    // Update JSON status indicator
+    function updateJsonStatus(isValid, message = null) {
+      const statusDiv = document.getElementById("json-status");
+      const errorDiv = document.getElementById("json-error");
+      
+      if (message !== null) {
+        statusDiv.textContent = message;
+        statusDiv.style.color = isValid ? "#2e7d32" : "#c62828";
+      } else if (isValid === true) {
+        statusDiv.textContent = "✓ Valid JSON";
+        statusDiv.style.color = "#2e7d32";
+        errorDiv.textContent = "";
+      } else if (isValid === false) {
+        statusDiv.textContent = "✗ Invalid JSON";
+        statusDiv.style.color = "#c62828";
+      } else {
+        // Clear status
+        statusDiv.textContent = "";
+        errorDiv.textContent = "";
+      }
+    }
+    
+    // Real-time JSON validation and auto-apply on input
+    document.getElementById("custom-json-input").addEventListener("input", () => {
+      const jsonInput = document.getElementById("custom-json-input").value.trim();
+      const errorDiv = document.getElementById("json-error");
+      
+      // Switch to custom mode when user starts editing
+      if (jsonInput) {
+        document.getElementById("radio-custom").checked = true;
+      }
+      
+      // Clear any existing auto-apply timer
+      if (autoApplyTimer) {
+        clearTimeout(autoApplyTimer);
+        autoApplyTimer = null;
+      }
+      
+      if (!jsonInput) {
+        updateJsonStatus(null);
+        errorDiv.textContent = "";
+        return;
+      }
+      
+      // Validate JSON
+      let isValid = false;
+      try {
+        const parsed = JSON.parse(jsonInput);
+        if (typeof parsed !== "object" || parsed === null) {
+          updateJsonStatus(false);
+          errorDiv.textContent = "JSON must be an object {} or array []";
+          errorDiv.style.color = "#c62828";
+          isValid = false;
+        } else {
+          updateJsonStatus(true);
+          errorDiv.textContent = "";
+          isValid = true;
+        }
+      } catch (error) {
+        updateJsonStatus(false);
+        errorDiv.textContent = `Invalid JSON: ${error.message}`;
+        errorDiv.style.color = "#c62828";
+        isValid = false;
+      }
+      
+      // Auto-apply valid JSON after user stops typing (1 second delay)
+      if (isValid) {
+        autoApplyTimer = setTimeout(() => {
+          // Only auto-apply if JSON is still valid and different from applied
+          if (hasUnsavedChanges()) {
+            applyJsonData();
+          }
+        }, 1000); // 1 second debounce
+      }
     });
     
     // Get value
@@ -410,7 +739,7 @@ Try the `nestedutils` library directly in your browser! This page uses [Pyodide]
         }
         
         pyodide.runPython(`set_at(data, ${JSON.stringify(path)}, ${JSON.stringify(parsedValue)}, fill_strategy=${JSON.stringify(strategy)})`);
-        updateDataDisplay();
+        updateDataDisplay(true);
         resultDiv.innerHTML = `<span class="result-success">✓ Value set successfully</span>`;
       } catch (error) {
         resultDiv.innerHTML = `<span class="result-error">Error: ${escapeHtml(error.message)}</span>`;
@@ -454,8 +783,8 @@ Try the `nestedutils` library directly in your browser! This page uses [Pyodide]
       
       try {
         resultDiv.innerHTML = '<span class="result-info">Processing...</span>';
-        const deleted = pyodide.runPython(`delete_at(data, ${JSON.stringify(path)}, allow_list_mutation=${allowListMutation})`);
-        updateDataDisplay();
+        const deleted = pyodide.runPython(`delete_at(data, ${JSON.stringify(path)}, allow_list_mutation=${allowListMutation ? 'True' : 'False'})`);
+        updateDataDisplay(true);
         
         // Format the deleted value for display
         let deletedStr;
diff --git a/nestedutils/helpers.py b/nestedutils/helpers.py
index 1e98356..c881216 100644
--- a/nestedutils/helpers.py
+++ b/nestedutils/helpers.py
@@ -23,7 +23,7 @@ def normalize_path(path: Union[str, List[Any]]) -> List[str]:
             or exceeds maximum depth.
     """
     if isinstance(path, list):
-        keys = [str(x) for x in path]
+        keys = [key for key in path]
     elif isinstance(path, str):
         keys = path.split(".")
     else:
diff --git a/pyproject.toml b/pyproject.toml
index 0541ac9..f76c9ff 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "nestedutils"
-version = "1.1.6"
+version = "1.1.7"
 description = "The lightweight Python library for safe, simple, dot-notation access to nested dicts and lists. Effortlessly get, set, and delete values deep in your complex JSON, API responses, and config files without verbose error-checking or handling KeyError exceptions."
 readme = "README.md"
 requires-python = ">=3.8"
diff --git a/tests/test_delete.py b/tests/test_delete.py
index 5ebc364..3c63c18 100644
--- a/tests/test_delete.py
+++ b/tests/test_delete.py
@@ -170,53 +170,6 @@ def test_delete_missing_intermediate_key(self):
         with pytest.raises(PathError) as exc_info:
             delete_at(d, "a.b.c")
         assert exc_info.value.code == PathErrorCode.MISSING_KEY
-    
-    def test_delete_empty_path(self):
-        """Delete with empty path should fail."""
-        d = {"a": 1}
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, "")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_delete_empty_key_in_middle(self):
-        """Delete with empty key in middle of path should fail."""
-        d = {"a": {"": {"b": 1}}}
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, "a..b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, ["a", "", "b"])
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_delete_path_validation_edge_cases(self):
-        """Test path validation for various edge cases with dots."""
-        d = {"a": {"b": 1}}
-        
-        # Leading dot
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, ".a.b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Trailing dot
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, "a.b.")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Just dots
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, "...")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Multiple consecutive dots
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, "a...b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Leading and trailing dots
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, ".a.b.")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
 
 
 class TestDeleteComplex:
@@ -262,23 +215,6 @@ def test_delete_after_set(self):
 class TestDeleteInvalidPaths:
     """Tests for invalid path types in delete_at."""
     
-    @pytest.mark.parametrize("invalid_path", [
-        123,
-        None,
-        {},
-        tuple(),
-        set(),
-        3.14,
-        True,
-        False,
-    ])
-    def test_delete_at_invalid_path_types(self, invalid_path):
-        """delete_at should raise PathError with INVALID_PATH code for invalid path types."""
-        d = {"a": 1}
-        with pytest.raises(PathError) as exc_info:
-            delete_at(d, invalid_path)
-        assert exc_info.value.code == PathErrorCode.INVALID_PATH
-    
     def test_delete_path_as_list(self):
         """Delete using list form path."""
         d = {"a": {"b": {"c": 1}}}
diff --git a/tests/test_edge_cases.py b/tests/test_edge_cases.py
index 59a534c..d64af72 100644
--- a/tests/test_edge_cases.py
+++ b/tests/test_edge_cases.py
@@ -61,18 +61,6 @@ def test_path_list_with_negative_index(self):
         assert get_at(d, ["a", -1]) == 30
         set_at(d, ["a", -1], 999)
         assert d["a"][2] == 999
-    
-    def test_path_list_empty_strings(self):
-        """List form with empty strings should raise PathError."""
-        d = {}
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, ["a", "", "b"], 1)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Also test with get_at
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, ["a", "", "b"])
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
 
 
 class TestComplexIntegrationScenarios:
diff --git a/tests/test_exists.py b/tests/test_exists.py
index 842c96e..3c0e6eb 100644
--- a/tests/test_exists.py
+++ b/tests/test_exists.py
@@ -185,74 +185,6 @@ def test_exists_mixed_types(self):
         assert exists_at(d, "b.dict.missing") is False
 
 
-class TestExistsInvalidPaths:
-    """Tests for invalid path types."""
-    
-    @pytest.mark.parametrize("invalid_path", [
-        123,
-        None,
-        {},
-        tuple(),
-        set(),
-        3.14,
-        True,
-        False,
-    ])
-    def test_exists_at_invalid_path_types(self, invalid_path):
-        """exists_at should raise PathError with INVALID_PATH code for invalid path types."""
-        d = {"a": 1}
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, invalid_path)
-        assert exc_info.value.code == PathErrorCode.INVALID_PATH
-    
-    def test_exists_empty_path(self):
-        """Exists with empty path should raise PathError."""
-        d = {"a": 1}
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, "")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_exists_empty_key_in_middle(self):
-        """Exists with empty key in middle of path should raise PathError."""
-        d = {"a": {"": {"b": 1}}}
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, "a..b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, ["a", "", "b"])
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_exists_path_validation_edge_cases(self):
-        """Test path validation for various edge cases with dots."""
-        d = {"a": {"b": 1}}
-        
-        # Leading dot
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, ".a.b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Trailing dot
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, "a.b.")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Just dots
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, "...")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Multiple consecutive dots
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, "a...b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Leading and trailing dots
-        with pytest.raises(PathError) as exc_info:
-            exists_at(d, ".a.b.")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-
-
 class TestExistsWithTuples:
     """Tests for exists_at with tuples."""
     
diff --git a/tests/test_get.py b/tests/test_get.py
index 63b31a7..5e3c7ac 100644
--- a/tests/test_get.py
+++ b/tests/test_get.py
@@ -16,6 +16,25 @@ def test_get_nested_dict(self):
         d = {"a": {"b": {"c": 5}}}
         assert get_at(d, "a.b.c") == 5
     
+    def test_get_intermediate_nested_object(self):
+        """Get intermediate path returns complete nested object."""
+        data = {
+            "user": {
+                "profile": {
+                    "email": "john@example.com",
+                    "address": {"city": "SF", "zip": "94102"}
+                }
+            }
+        }
+        # Getting intermediate path should return complete nested structure
+        profile = get_at(data, "user.profile")
+        assert profile == {
+            "email": "john@example.com",
+            "address": {"city": "SF", "zip": "94102"}
+        }
+        # Can also get deeper values
+        assert get_at(data, "user.profile.address.city") == "SF"
+    
     def test_get_missing_returns_default(self):
         """Get missing key returns default value."""
         d = {"a": {"b": 1}}
@@ -119,6 +138,28 @@ def test_keys_with_dots_in_list_form(self):
         """List form allows keys with dots."""
         d = {"a.b": {"c.d": 10}}
         assert get_at(d, ["a.b", "c.d"]) == 10
+    
+    def test_complex_keys_in_list_form(self):
+        """List form handles any key type: special characters, dots, integers."""
+        # Create data structure with complex keys
+        data = {
+            "user-info": {
+                "first.name": {
+                    123: "found it!"
+                }
+            }
+        }
+        
+        # Verify each level works independently
+        assert get_at(data, ["user-info"]) == {"first.name": {123: "found it!"}}
+        assert get_at(data, ["user-info", "first.name"]) == {123: "found it!"}
+        
+        # String form cannot handle these keys (dots would be interpreted as separators)
+        # But list form works perfectly
+        assert get_at(data, ["user-info", "first.name", 123]) == "found it!"
+        
+        # Test with default for missing path
+        assert get_at(data, ["user-info", "first.name", 999], default="not found") == "not found"
 
 
 class TestGetEdgeCases:
@@ -140,6 +181,33 @@ def test_get_none_value(self):
         d = {"a": None}
         assert get_at(d, "a") is None
     
+    def test_none_blocks_navigation(self):
+        """None as intermediate value should block navigation and return default."""
+        # None at first level blocks further navigation
+        d = {"a": None}
+        assert get_at(d, "a.b") is None
+        assert get_at(d, "a.b", default="missing") == "missing"
+        assert get_at(d, "a.b.c") is None
+        assert get_at(d, "a.b.c", default=99) == 99
+        
+        # None at deeper level also blocks navigation
+        d2 = {"a": {"b": None}}
+        assert get_at(d2, "a.b.c") is None
+        assert get_at(d2, "a.b.c", default="not found") == "not found"
+        assert get_at(d2, "a.b.c.d.e") is None
+        
+        # None in list should also block navigation
+        d3 = {"items": [None, {"name": "apple"}]}
+        assert get_at(d3, "items.0.name") is None
+        assert get_at(d3, "items.0.name", default="no name") == "no name"
+        
+        # None in nested structure
+        d4 = {"data": {"user": None, "other": {"value": 42}}}
+        assert get_at(d4, "data.user.name") is None
+        assert get_at(d4, "data.user.name", default="default") == "default"
+        # But other paths should still work
+        assert get_at(d4, "data.other.value") == 42
+    
     def test_get_false_value(self):
         """Get False value (should not be confused with missing)."""
         d = {"a": False}
@@ -166,6 +234,28 @@ def test_get_from_dict_with_numeric_keys(self):
         d = {"0": {"1": {"2": 5}}}
         assert get_at(d, "0.1.2") == 5
     
+    def test_get_dict_with_integer_vs_string_keys(self):
+        """Test that integer and string keys are correctly distinguished.
+        
+        The library correctly preserves key types in list form paths, allowing
+        access to both integer keys and string keys with the same numeric value.
+        """
+        # Dictionary with both integer key and string key
+        data = {0: "int_value", "0": "string_value"}
+        
+        # Using integer in path accesses integer key
+        assert get_at(data, [0]) == "int_value"
+        
+        # Using string in path accesses string key
+        assert get_at(data, ["0"]) == "string_value"
+        
+        # Verify direct access matches
+        assert data[0] == "int_value"
+        assert data["0"] == "string_value"
+        
+        # Both keys are distinct and accessible
+        assert get_at(data, [0]) != get_at(data, ["0"])
+    
     def test_get_mixed_types(self):
         """Get from structure with mixed types."""
         d = {
@@ -178,71 +268,3 @@ def test_get_mixed_types(self):
         assert get_at(d, "b.list.1") == 20
         assert get_at(d, "b.dict.nested") == "value"
 
-
-class TestGetInvalidPaths:
-    """Tests for invalid path types."""
-    
-    @pytest.mark.parametrize("invalid_path", [
-        123,
-        None,
-        {},
-        tuple(),
-        set(),
-        3.14,
-        True,
-        False,
-    ])
-    def test_get_at_invalid_path_types(self, invalid_path):
-        """get_at should raise PathError with INVALID_PATH code for invalid path types."""
-        d = {"a": 1}
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, invalid_path)
-        assert exc_info.value.code == PathErrorCode.INVALID_PATH
-    
-    def test_get_empty_path(self):
-        """Get with empty path should raise PathError."""
-        d = {"a": 1}
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, "")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_get_empty_key_in_middle(self):
-        """Get with empty key in middle of path should raise PathError."""
-        d = {"a": {"": {"b": 1}}}
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, "a..b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, ["a", "", "b"])
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_get_path_validation_edge_cases(self):
-        """Test path validation for various edge cases with dots."""
-        d = {"a": {"b": 1}}
-        
-        # Leading dot
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, ".a.b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Trailing dot
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, "a.b.")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Just dots
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, "...")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Multiple consecutive dots
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, "a...b")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Leading and trailing dots
-        with pytest.raises(PathError) as exc_info:
-            get_at(d, ".a.b.")
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-
diff --git a/tests/test_normalize_path.py b/tests/test_normalize_path.py
new file mode 100644
index 0000000..fb2002c
--- /dev/null
+++ b/tests/test_normalize_path.py
@@ -0,0 +1,102 @@
+"""Tests for normalize_path helper function."""
+
+import pytest
+from nestedutils.helpers import normalize_path
+from nestedutils.exceptions import PathError
+from nestedutils.enums import PathErrorCode
+
+
+class TestNormalizePathValid:
+    """Test valid path normalization."""
+    
+    @pytest.mark.parametrize("path,expected", [
+        # String paths
+        ("a", ["a"]),
+        ("a.b", ["a", "b"]),
+        ("a.b.c", ["a", "b", "c"]),
+        ("user.profile.name", ["user", "profile", "name"]),
+        ("items.0.name", ["items", "0", "name"]),
+        ("data.-1", ["data", "-1"]),
+        
+        # List paths - simple
+        (["a"], ["a"]),
+        (["a", "b"], ["a", "b"]),
+        (["a", "b", "c"], ["a", "b", "c"]),
+        
+        # List paths - mixed types (converted to strings)
+        (["user", 0, "name"], ["user", 0, "name"]),
+        ([0, 1, 2], [0, 1, 2]),
+        (["items", -1], ["items", -1]),
+    ])
+    def test_valid_paths(self, path, expected):
+        """Test that valid paths are normalized correctly."""
+        assert normalize_path(path) == expected
+
+
+class TestNormalizePathInvalid:
+    """Test invalid path handling."""
+    
+    @pytest.mark.parametrize("path,error_code", [
+        # Empty paths
+        ("", PathErrorCode.EMPTY_PATH),
+        ([], PathErrorCode.EMPTY_PATH),
+        
+        # Empty keys in string paths
+        (".a", PathErrorCode.EMPTY_PATH),          # Leading dot
+        ("a.", PathErrorCode.EMPTY_PATH),          # Trailing dot
+        ("a..b", PathErrorCode.EMPTY_PATH),        # Double dot
+        (".a.b", PathErrorCode.EMPTY_PATH),        # Leading dot
+        ("a.b.", PathErrorCode.EMPTY_PATH),        # Trailing dot
+        ("..", PathErrorCode.EMPTY_PATH),          # Just dots
+        ("...", PathErrorCode.EMPTY_PATH),         # Multiple dots
+        
+        # Empty keys in list paths
+        ([""], PathErrorCode.EMPTY_PATH),
+        (["a", ""], PathErrorCode.EMPTY_PATH),
+        (["", "a"], PathErrorCode.EMPTY_PATH),
+        (["a", "", "b"], PathErrorCode.EMPTY_PATH),
+    ])
+    def test_invalid_paths_raise_error(self, path, error_code):
+        """Test that invalid paths raise PathError with correct code."""
+        with pytest.raises(PathError) as exc_info:
+            normalize_path(path)
+        assert exc_info.value.code == error_code
+    
+    @pytest.mark.parametrize("path", [
+        123,           # Integer
+        12.34,         # Float
+        None,          # None
+        {"a": 1},      # Dict
+        True,          # Boolean
+    ])
+    def test_invalid_types(self, path):
+        """Test that invalid path types raise PathError."""
+        with pytest.raises(PathError) as exc_info:
+            normalize_path(path)
+        assert exc_info.value.code == PathErrorCode.INVALID_PATH
+
+
+class TestNormalizePathDepth:
+    """Test path depth validation."""
+    
+    def test_max_depth_string(self):
+        """Test that paths exceeding max depth raise error."""
+        # Create a path with 101 keys (MAX_DEPTH is 100)
+        deep_path = ".".join(str(i) for i in range(101))
+        with pytest.raises(PathError) as exc_info:
+            normalize_path(deep_path)
+        assert exc_info.value.code == PathErrorCode.INVALID_PATH
+    
+    def test_max_depth_list(self):
+        """Test that list paths exceeding max depth raise error."""
+        deep_path = [str(i) for i in range(101)]
+        with pytest.raises(PathError) as exc_info:
+            normalize_path(deep_path)
+        assert exc_info.value.code == PathErrorCode.INVALID_PATH
+    
+    def test_exactly_max_depth(self):
+        """Test that paths at exactly max depth are valid."""
+        # Create a path with exactly 100 keys
+        path = ".".join(str(i) for i in range(100))
+        result = normalize_path(path)
+        assert len(result) == 100
diff --git a/tests/test_set.py b/tests/test_set.py
index 9c6e3c0..bb84364 100644
--- a/tests/test_set.py
+++ b/tests/test_set.py
@@ -244,60 +244,6 @@ def test_set_at_invalid_type(self):
             set_at(d, "a.b", 10)
         assert exc_info.value.code == PathErrorCode.INVALID_PATH
     
-    def test_empty_string_path(self):
-        """Empty path should raise PathError."""
-        d = {"a": 1}
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, "", 5)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_empty_key_in_middle(self):
-        """Set with empty key in middle of path should raise PathError."""
-        d = {}
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, "a..b", 1)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, ["a", "", "b"], 1)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_set_path_validation_edge_cases(self):
-        """Test path validation for various edge cases with dots."""
-        d = {}
-        
-        # Leading dot
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, ".a.b", 1)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Trailing dot
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, "a.b.", 1)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Just dots
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, "...", 1)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Multiple consecutive dots
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, "a...b", 1)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-        
-        # Leading and trailing dots
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, ".a.b.", 1)
-        assert exc_info.value.code == PathErrorCode.EMPTY_PATH
-    
-    def test_set_negative_index_on_empty_list(self):
-        """Can't use negative index on empty list."""
-        d = {"a": []}
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, "a.-1", 5)
-        assert exc_info.value.code == PathErrorCode.INVALID_INDEX
-    
     def test_set_negative_index_on_empty_list(self):
         """Can't use negative index on empty list."""
         d = {"a": []}
@@ -430,25 +376,3 @@ def test_set_overwrite_existing_value(self):
         d = {"a": {"b": 1}}
         set_at(d, "a.b", 2)
         assert d == {"a": {"b": 2}}
-
-
-class TestSetInvalidPaths:
-    """Tests for invalid path types in set_at."""
-    
-    @pytest.mark.parametrize("invalid_path", [
-        123,
-        None,
-        {},
-        tuple(),
-        set(),
-        3.14,
-        True,
-        False,
-    ])
-    def test_set_at_invalid_path_types(self, invalid_path):
-        """set_at should raise PathError with INVALID_PATH code for invalid path types."""
-        d = {}
-        with pytest.raises(PathError) as exc_info:
-            set_at(d, invalid_path, "value")
-        assert exc_info.value.code == PathErrorCode.INVALID_PATH
-
diff --git a/uv.lock b/uv.lock
index fae511d..c141aa8 100644
--- a/uv.lock
+++ b/uv.lock
@@ -837,7 +837,7 @@ wheels = [
 
 [[package]]
 name = "nestedutils"
-version = "1.1.6"
+version = "1.1.7"
 source = { editable = "." }
 
 [package.dev-dependencies]