@@ -58,53 +58,6 @@ const VARYING_TOKEN_KINDS: &[&str] = &[
     "unknown",
 ];
 
-/// Maximum structural nesting accepted in the serialized JSON tree.
-///
-/// This exceeds the deepest tree in the Swift corpus while bounding the
-/// recursive serde deserialization and AST construction that follow.
-const MAX_JSON_DEPTH: usize = 2048;
-
-/// Check JSON structural depth without recursively parsing it.
-///
-/// Brackets and braces inside strings are ignored. Full JSON validation is
-/// still performed by serde_json afterward.
-fn check_json_depth(json: &str) -> Result<(), String> {
-    let mut depth = 0;
-    let mut in_string = false;
-    let mut escaped = false;
-
-    for byte in json.bytes() {
-        if in_string {
-            if escaped {
-                escaped = false;
-            } else {
-                match byte {
-                    b'\\' => escaped = true,
-                    b'"' => in_string = false,
-                    _ => {}
-                }
-            }
-        } else {
-            match byte {
-                b'"' => in_string = true,
-                b'{' | b'[' => {
-                    depth += 1;
-                    if depth > MAX_JSON_DEPTH {
-                        return Err(format!(
-                            "invalid JSON: nesting depth exceeds supported maximum \
-                             ({MAX_JSON_DEPTH})"
-                        ));
-                    }
-                }
-                b'}' | b']' => depth = depth.saturating_sub(1),
-                _ => {}
-            }
-        }
-    }
-
-    Ok(())
-}
-
 /// Keys of a node object that carry metadata rather than a structural child.
 fn is_metadata_key(key: &str) -> bool {
     matches!(
@@ -373,7 +326,6 @@ const SWIFT_NODE_TYPES: &str = include_str!("../../../swift_node_types.yml");
 /// authoritative swift-syntax schema ([`SWIFT_NODE_TYPES`]); the adapter only
 /// ever consumes swift-syntax input, so the schema is not a parameter.
 pub fn json_to_ast(json: &str) -> Result<AdaptedTree, String> {
-    check_json_depth(json)?;
     let mut deserializer = serde_json::Deserializer::from_str(json);
     deserializer.disable_recursion_limit();
     let root = Value::deserialize(&mut deserializer).map_err(|e| format!("invalid JSON: {e}"))?;
@@ -582,25 +534,6 @@ mod tests {
         json_to_ast(&json).expect("adapter should accept JSON nested beyond serde_json's default");
     }
 
-    #[test]
-    fn rejects_json_beyond_supported_depth() {
-        let json = deeply_nested_json(MAX_JSON_DEPTH);
-        let error = match json_to_ast(&json) {
-            Ok(_) => panic!("adapter should reject excessively nested JSON"),
-            Err(error) => error,
-        };
-        assert!(
-            error.contains("nesting depth exceeds supported maximum"),
-            "{error}"
-        );
-    }
-
-    #[test]
-    fn ignores_brackets_inside_json_strings_when_checking_depth() {
-        check_json_depth(r#"{"text":"[[[{{{\\\""}"#)
-            .expect("string contents should not contribute to JSON depth");
-    }
-
     #[test]
     fn collects_extras_into_side_channel() {
         // A token carrying a trailing line comment in its trivia.
 
@@ -136,6 +136,15 @@ mod tests {
         );
     }
 
+    #[test]
+    fn rejects_excessively_deep_syntax_tree() {
+        let source = format!("let x = a{}\n", ".a".repeat(2100));
+        assert!(
+            matches!(parse_to_json(&source), Err(ParseError::SwiftFailure)),
+            "serialization should reject syntax trees beyond the supported depth"
+        );
+    }
+
     #[test]
     fn serializes_json_strings_and_keys_deterministically() {
         let source = "/* quote \" slash / backslash \\ tab \t newline\n emoji 😀 combining e\u{301} control \u{1} */\nlet x = 1";
 
@@ -85,10 +85,22 @@ private func serializeTrivia(
 ///     therefore simply a JSON array. This drops the collection node's own
 ///     `kind`/location, which are unnamed and largely recoverable from the
 ///     elements.
-private func serialize(_ node: Syntax) -> Any {
+private let maximumSerializationDepth = 2048
+
+private struct SerializationDepthError: Error, CustomStringConvertible {
+    var description: String {
+        "syntax tree exceeds maximum serialization depth (\(maximumSerializationDepth))"
+    }
+}
+
+private func serialize(_ node: Syntax, depth: Int = 1) throws -> Any {
+    if depth > maximumSerializationDepth {
+        throw SerializationDepthError()
+    }
+
     if node.kind.isSyntaxCollection {
-        return node.children(viewMode: .sourceAccurate).map {
-            serialize($0)
+        return try node.children(viewMode: .sourceAccurate).map {
+            try serialize($0, depth: depth + 1)
         }
     }
 
@@ -133,10 +145,10 @@ private func serialize(_ node: Syntax) -> Any {
         // parent (the same mechanism SwiftSyntax uses for its debug dump). A
         // child that is a collection serializes to an array (see above).
         if let keyPath = child.keyPathInParent, let name = childName(keyPath) {
-            result[name] = serialize(child)
+            result[name] = try serialize(child, depth: depth + 1)
         } else {
             // Defensive fallback for any unnamed layout child.
-            result["child\(unnamed)"] = serialize(child)
+            result["child\(unnamed)"] = try serialize(child, depth: depth + 1)
             unnamed += 1
         }
     }
@@ -311,7 +323,14 @@ public func ssr_parse_json(
     // converter built from the original tree maps the folded tree correctly.
     let folded = foldOperators(in: tree)
     let converter = SourceLocationConverter(fileName: "<input>", tree: tree)
-    guard var json = serialize(folded) as? [String: Any] else {
+    let serialized: Any
+    do {
+        serialized = try serialize(folded)
+    } catch {
+        writeToStandardError("SwiftSyntaxFFI: JSON serialization failed: \(error)\n")
+        return nil
+    }
+    guard var json = serialized as? [String: Any] else {
         return nil
     }
     json["$lineStarts"] = lineStarts(converter)