From bfb85334541e44cf03823fe8f0f80c89ee1feeba Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Sat, 11 Apr 2026 02:20:31 +0800
Subject: feat: implement basic HTTP client with socket and address networking
 utilities

---
 ricochet/src/net/http_client.cc | 118 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 ricochet/src/net/http_client.cc

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
new file mode 100644
index 0000000..256c1f2
--- /dev/null
+++ b/ricochet/src/net/http_client.cc
@@ -0,0 +1,118 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/net/http_client.hh"
+
+#include "ricochet/net/sys/address.hh"
+#include "ricochet/net/sys/socket.hh"
+
+#include <cstddef>
+#include <format>
+#include <string>
+
+namespace ricochet::net {
+
+namespace {
+
+struct ParsedUrl
+{
+  std::string host {};
+  std::string path {};
+};
+
+std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
+{
+  const std::string_view http_prefix = "http://";
+
+  if ( !url.starts_with( http_prefix ) ) {
+    return std::unexpected( "Only 'http://' URLs are supported in MVP. (e.g., http://example.com)" );
+  }
+
+  url.remove_prefix( http_prefix.length() );
+  auto slash_pos = url.find( '/' );
+
+  ParsedUrl result;
+  if ( slash_pos == std::string_view::npos ) {
+    result.host = std::string( url );
+    result.path = "/";
+  } else {
+    result.host = std::string( url.substr( 0, slash_pos ) );
+    result.path = std::string( url.substr( slash_pos ) );
+  }
+
+  return result;
+}
+} // namespace
+
+std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url ) const // NOLINT(readability-convert-member-functions-to-static)
+{
+  auto parsed_url = parse_url( url );
+  if ( !parsed_url.has_value() ) {
+    return std::unexpected( parsed_url.error() );
+  }
+
+  auto [host, path] = parsed_url.value();
+
+  try {
+    const Address server_addr( host, "http" );
+
+    TCPSocket socket;
+    socket.connect( server_addr );
+
+    const std::string request = std::format( "GET {} HTTP/1.1\r\n"
+                                       "Host: {}\r\n"
+                                       "User-Agent: Ricochet/0.1.0\r\n"
+                                       "Connection: close\r\n\r\n",
+                                       path,
+                                       host );
+
+    size_t bytes_written = 0;
+    while ( bytes_written < request.size() ) {
+      bytes_written += socket.write( request.substr( bytes_written ) );
+    }
+
+    std::string raw_response;
+    while ( !socket.eof() ) {
+      std::string buffer;
+      socket.read( buffer );
+      raw_response += buffer;
+    }
+
+    HttpResponse response;
+    auto header_end = raw_response.find( "\r\n\r\n" );
+
+    if ( header_end != std::string::npos ) {
+      response.body = raw_response.substr( header_end + 4 );
+      if ( raw_response.size() >= 12 ) {
+        try {
+          response.status_code = std::stoi( raw_response.substr( 9, 3 ) );
+        } catch ( ... ) {
+          response.status_code = 0;
+        }
+      }
+    } else {
+      response.body = raw_response;
+    }
+
+    return response;
+  } catch ( const std::exception& e ) {
+    return std::unexpected( std::string( "Network Error: " ) + e.what() );
+  }
+}
+
+} // namespace ricochet::net
\ No newline at end of file
-- 
cgit v1.2.3


From 86f0162f5556e25ce6a5b9b1327ff7ef2800d5c1 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Sat, 11 Apr 2026 03:28:01 +0800
Subject: style: apply consistent code formatting and bracing style across the
 codebase

---
 ricochet/include/ricochet/parser/dom_tree.hh     |   9 +-
 ricochet/include/ricochet/parser/html_lexer.hh   |  17 ++--
 ricochet/include/ricochet/parser/tree_builder.hh |  27 ++---
 ricochet/src/core/browser.cc                     |  50 +++++-----
 ricochet/src/net/http_client.cc                  |  13 +--
 ricochet/src/parser/html_lexer.cc                | 122 ++++++++++++-----------
 ricochet/src/parser/tree_builder.cc              |  87 ++++++++--------
 7 files changed, 162 insertions(+), 163 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/include/ricochet/parser/dom_tree.hh b/ricochet/include/ricochet/parser/dom_tree.hh
index b1e4812..e3b3664 100644
--- a/ricochet/include/ricochet/parser/dom_tree.hh
+++ b/ricochet/include/ricochet/parser/dom_tree.hh
@@ -26,10 +26,11 @@ namespace ricochet::parser {
 /**
  * @brief DOM Node. Pure value semantics, no pointers.
  */
-struct DomNode {
-    std::string tag_name{};    // If empty, it's a pure text node
-    std::string text_content{}; // Only meaningful when tag_name is empty
-    std::vector<DomNode> children{}; // Recursive child nodes list
+struct DomNode
+{
+  std::string tag_name {};          // If empty, it's a pure text node
+  std::string text_content {};      // Only meaningful when tag_name is empty
+  std::vector<DomNode> children {}; // Recursive child nodes list
 };
 
 } // namespace ricochet::parser
\ No newline at end of file
diff --git a/ricochet/include/ricochet/parser/html_lexer.hh b/ricochet/include/ricochet/parser/html_lexer.hh
index 2cfdda9..d9ce23a 100644
--- a/ricochet/include/ricochet/parser/html_lexer.hh
+++ b/ricochet/include/ricochet/parser/html_lexer.hh
@@ -25,16 +25,19 @@
 
 namespace ricochet::parser {
 
-struct TextToken {
-    std::string content{};
+struct TextToken
+{
+  std::string content {};
 };
 
-struct TagOpenToken {
-    std::string name{};
+struct TagOpenToken
+{
+  std::string name {};
 };
 
-struct TagCloseToken {
-    std::string name{};
+struct TagCloseToken
+{
+  std::string name {};
 };
 
 using HtmlToken = std::variant<TextToken, TagOpenToken, TagCloseToken>;
@@ -53,7 +56,7 @@ public:
   /**
    * @brief Perform lexical analysis to convert HTML source code into a structured sequence of tokens
    */
-  std::vector<HtmlToken> tokenize(std::string_view html) const;
+  std::vector<HtmlToken> tokenize( std::string_view html ) const;
 
 private:
 };
diff --git a/ricochet/include/ricochet/parser/tree_builder.hh b/ricochet/include/ricochet/parser/tree_builder.hh
index 4adbc4d..2cb0748 100644
--- a/ricochet/include/ricochet/parser/tree_builder.hh
+++ b/ricochet/include/ricochet/parser/tree_builder.hh
@@ -25,20 +25,21 @@
 
 namespace ricochet::parser {
 
-class TreeBuilder {
+class TreeBuilder
+{
 public:
-    TreeBuilder() = default;
-    ~TreeBuilder() = default;
-
-    TreeBuilder(const TreeBuilder&) = delete;
-    TreeBuilder& operator=(const TreeBuilder&) = delete;
-    TreeBuilder(TreeBuilder&&) = delete;
-    TreeBuilder& operator=(TreeBuilder&&) = delete;
-
-    /**
-     * @brief Assemble a one-dimensional token sequence into a multi-dimensional DOM tree
-     */
-    DomNode build(const std::vector<HtmlToken>& tokens) const;
+  TreeBuilder() = default;
+  ~TreeBuilder() = default;
+
+  TreeBuilder( const TreeBuilder& ) = delete;
+  TreeBuilder& operator=( const TreeBuilder& ) = delete;
+  TreeBuilder( TreeBuilder&& ) = delete;
+  TreeBuilder& operator=( TreeBuilder&& ) = delete;
+
+  /**
+   * @brief Assemble a one-dimensional token sequence into a multi-dimensional DOM tree
+   */
+  DomNode build( const std::vector<HtmlToken>& tokens ) const;
 };
 
 } // namespace ricochet::parser
\ No newline at end of file
diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index 7acc915..e4c4c60 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -23,18 +23,18 @@
 #include <iostream>
 
 namespace {
-void print_dom_tree(const ricochet::parser::DomNode& node, std::size_t depth = 0) // NOLINT(misc-no-recursion)
+void print_dom_tree( const ricochet::parser::DomNode& node, std::size_t depth = 0 ) // NOLINT(misc-no-recursion)
 {
-    const std::string indent(depth * 2, ' ');
-    
-    if (node.tag_name.empty()) {
-        std::cout << indent << "\"" << node.text_content << "\"\n";
-    } else {
-        std::cout << indent << "<" << node.tag_name << ">\n";
-        for (const auto& child : node.children) {
-            print_dom_tree(child, depth + 1);
-        }
+  const std::string indent( depth * 2, ' ' );
+
+  if ( node.tag_name.empty() ) {
+    std::cout << indent << "\"" << node.text_content << "\"\n";
+  } else {
+    std::cout << indent << "<" << node.tag_name << ">\n";
+    for ( const auto& child : node.children ) {
+      print_dom_tree( child, depth + 1 );
     }
+  }
 }
 } // namespace
 namespace ricochet::core {
@@ -43,26 +43,26 @@ int Browser::run( std::string_view initial_url )
 {
   std::cout << "-> Fetching: " << initial_url << "...\n";
 
-    const net::HttpClient client;
-    auto response_result = client.fetch(initial_url);
+  const net::HttpClient client;
+  auto response_result = client.fetch( initial_url );
 
-    if (!response_result.has_value()) {
-        std::cerr << "[!] Ricochet failed to load page: " << response_result.error() << "\n";
-        return 1;
-    }
+  if ( !response_result.has_value() ) {
+    std::cerr << "[!] Ricochet failed to load page: " << response_result.error() << "\n";
+    return 1;
+  }
+
+  const auto& response = response_result.value();
 
-    const auto& response = response_result.value();
-    
-    const parser::HtmlLexer lexer;
-    const auto tokens = lexer.tokenize(response.body);
+  const parser::HtmlLexer lexer;
+  const auto tokens = lexer.tokenize( response.body );
 
-    const parser::TreeBuilder builder;
-    const auto dom_root = builder.build(tokens);
+  const parser::TreeBuilder builder;
+  const auto dom_root = builder.build( tokens );
 
-    std::cout << "\n[=== Abstract Syntax Tree (DOM) ===]\n";
-    print_dom_tree(dom_root);
+  std::cout << "\n[=== Abstract Syntax Tree (DOM) ===]\n";
+  print_dom_tree( dom_root );
 
-    return 0;
+  return 0;
 }
 
 } // namespace ricochet::core
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 256c1f2..d45de40 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -59,7 +59,8 @@ std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
 }
 } // namespace
 
-std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url ) const // NOLINT(readability-convert-member-functions-to-static)
+std::expected<HttpResponse, std::string> HttpClient::fetch( // NOLINT(readability-convert-member-functions-to-static)
+  std::string_view url ) const
 {
   auto parsed_url = parse_url( url );
   if ( !parsed_url.has_value() ) {
@@ -75,11 +76,11 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     socket.connect( server_addr );
 
     const std::string request = std::format( "GET {} HTTP/1.1\r\n"
-                                       "Host: {}\r\n"
-                                       "User-Agent: Ricochet/0.1.0\r\n"
-                                       "Connection: close\r\n\r\n",
-                                       path,
-                                       host );
+                                             "Host: {}\r\n"
+                                             "User-Agent: Ricochet/0.1.0\r\n"
+                                             "Connection: close\r\n\r\n",
+                                             path,
+                                             host );
 
     size_t bytes_written = 0;
     while ( bytes_written < request.size() ) {
diff --git a/ricochet/src/parser/html_lexer.cc b/ricochet/src/parser/html_lexer.cc
index bbf8c57..73591b3 100644
--- a/ricochet/src/parser/html_lexer.cc
+++ b/ricochet/src/parser/html_lexer.cc
@@ -21,99 +21,101 @@
 #include <cstdint>
 #include <string_view>
 
-
 namespace ricochet::parser {
 
 namespace {
-enum class LexerState : std::uint8_t {
-    Data,              // Reading plain text
-    TagOpen,           // Just encountered '<'
-    TagName,           // Reading the name of an opening tag (e.g., "div")
-    ClosingTagName,    // Reading the name of a closing tag (e.g., "/div")
-    SwallowAttributes  // Ignore attributes mode (ignore until encountering '>')
+enum class LexerState : std::uint8_t
+{
+  Data,             // Reading plain text
+  TagOpen,          // Just encountered '<'
+  TagName,          // Reading the name of an opening tag (e.g., "div")
+  ClosingTagName,   // Reading the name of a closing tag (e.g., "/div")
+  SwallowAttributes // Ignore attributes mode (ignore until encountering '>')
 };
 
-void emit_text(std::string& buffer, std::vector<HtmlToken>& tokens) {
-    if (buffer.empty()) {
-        return; // 提前返回，减少 if 嵌套层级
-    }
+void emit_text( std::string& buffer, std::vector<HtmlToken>& tokens )
+{
+  if ( buffer.empty() ) {
+    return; // 提前返回，减少 if 嵌套层级
+  }
 
-    bool all_whitespace = true;
-    for (const char c : buffer) {
-        if (!std::isspace(static_cast<unsigned char>(c))) {
-            all_whitespace = false;
-            break;
-        }
-    }
-    
-    if (!all_whitespace) {
-        tokens.emplace_back(TextToken{buffer});
+  bool all_whitespace = true;
+  for ( const char c : buffer ) {
+    if ( !std::isspace( static_cast<unsigned char>( c ) ) ) {
+      all_whitespace = false;
+      break;
     }
-    buffer.clear();
+  }
+
+  if ( !all_whitespace ) {
+    tokens.emplace_back( TextToken { buffer } );
+  }
+  buffer.clear();
 }
 
 } // namespace
 
-std::vector<HtmlToken> HtmlLexer::tokenize( std::string_view html ) const // NOLINT(readability-convert-member-functions-to-static)
+std::vector<HtmlToken> HtmlLexer::tokenize( // NOLINT(readability-convert-member-functions-to-static)
+  std::string_view html ) const
 {
   std::vector<HtmlToken> tokens;
 
   LexerState state = LexerState::Data;
-  std::string buffer{};
+  std::string buffer {};
 
-  for (const char c : html) {
-    switch (state) {
-    case LexerState::Data:
-        if (c == '<') {
-            emit_text(buffer, tokens);
-            state = LexerState::TagOpen;
+  for ( const char c : html ) {
+    switch ( state ) {
+      case LexerState::Data:
+        if ( c == '<' ) {
+          emit_text( buffer, tokens );
+          state = LexerState::TagOpen;
         } else {
-            buffer += c;
+          buffer += c;
         }
         break;
-    case LexerState::TagOpen:
-        if (c == '/') {
-            state = LexerState::ClosingTagName;
-        } else if (std::isalpha(static_cast<unsigned char>(c))) {
-            buffer.push_back(c);
-            state = LexerState::TagName;
+      case LexerState::TagOpen:
+        if ( c == '/' ) {
+          state = LexerState::ClosingTagName;
+        } else if ( std::isalpha( static_cast<unsigned char>( c ) ) ) {
+          buffer.push_back( c );
+          state = LexerState::TagName;
         } else {
-            buffer.push_back('<');
-            buffer.push_back(c);
-            state = LexerState::Data;
+          buffer.push_back( '<' );
+          buffer.push_back( c );
+          state = LexerState::Data;
         }
         break;
-    case LexerState::TagName:
-        if (c == '>') {
-            tokens.emplace_back(TagOpenToken{buffer});
-            buffer.clear();
-            state = LexerState::Data;
-        } else if (std::isspace(static_cast<unsigned char>(c))) {
-            tokens.emplace_back(TagOpenToken{buffer});
-            buffer.clear();
-            state = LexerState::SwallowAttributes;
+      case LexerState::TagName:
+        if ( c == '>' ) {
+          tokens.emplace_back( TagOpenToken { buffer } );
+          buffer.clear();
+          state = LexerState::Data;
+        } else if ( std::isspace( static_cast<unsigned char>( c ) ) ) {
+          tokens.emplace_back( TagOpenToken { buffer } );
+          buffer.clear();
+          state = LexerState::SwallowAttributes;
         } else {
-            buffer += static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+          buffer += static_cast<char>( std::tolower( static_cast<unsigned char>( c ) ) );
         }
         break;
-    case LexerState::ClosingTagName:
-        if (c == '>') {
-            tokens.emplace_back(TagCloseToken{buffer});
-            buffer.clear();
-            state = LexerState::Data;
+      case LexerState::ClosingTagName:
+        if ( c == '>' ) {
+          tokens.emplace_back( TagCloseToken { buffer } );
+          buffer.clear();
+          state = LexerState::Data;
         } else {
-            buffer += static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+          buffer += static_cast<char>( std::tolower( static_cast<unsigned char>( c ) ) );
         }
         break;
-    case LexerState::SwallowAttributes:
-        if (c == '>') {
-            state = LexerState::Data;
+      case LexerState::SwallowAttributes:
+        if ( c == '>' ) {
+          state = LexerState::Data;
         }
         break;
     }
   }
 
-  emit_text(buffer, tokens);
+  emit_text( buffer, tokens );
 
   return tokens;
 }
diff --git a/ricochet/src/parser/tree_builder.cc b/ricochet/src/parser/tree_builder.cc
index 51a8a51..4f7f87e 100644
--- a/ricochet/src/parser/tree_builder.cc
+++ b/ricochet/src/parser/tree_builder.cc
@@ -24,67 +24,58 @@
 namespace ricochet::parser {
 
 namespace {
-struct TokenVisitor {
-    std::vector<DomNode>* stack;
+struct TokenVisitor
+{
+  std::vector<DomNode>* stack;
 
-    void operator()(const TextToken& token) const {
-        stack->back().children.emplace_back(
-            DomNode{
-                .tag_name = "",
-                .text_content = token.content, 
-                .children = {}
-            }
-        );
-    }
+  void operator()( const TextToken& token ) const
+  {
+    stack->back().children.emplace_back(
+      DomNode { .tag_name = "", .text_content = token.content, .children = {} } );
+  }
+
+  void operator()( const TagOpenToken& token ) const
+  {
+    DomNode new_node { .tag_name = token.name, .text_content = "", .children = {} };
 
-    void operator()(const TagOpenToken& token) const {
-        DomNode new_node{
-            .tag_name = token.name, 
-            .text_content = "", 
-            .children = {}
-        };
+    if ( token.name == "meta" || token.name == "link" || token.name == "img" || token.name == "br"
+         || token.name == "hr" || token.name == "input" || token.name == "base" || token.name == "col" ) {
 
-        if (token.name == "meta" || token.name == "link" || token.name == "img" || 
-            token.name == "br" || token.name == "hr" || token.name == "input" || 
-            token.name == "base" || token.name == "col") {
-            
-            stack->back().children.push_back(std::move(new_node));
-        } else {
-            stack->push_back(std::move(new_node));
-        }
+      stack->back().children.push_back( std::move( new_node ) );
+    } else {
+      stack->push_back( std::move( new_node ) );
     }
+  }
 
-    void operator()(const TagCloseToken& /*token*/) const {
-        if (stack->size() > 1) {
-            DomNode completed_node = std::move(stack->back());
-            stack->pop_back();
-            stack->back().children.push_back(std::move(completed_node));
-        }
+  void operator()( const TagCloseToken& /*token*/ ) const
+  {
+    if ( stack->size() > 1 ) {
+      DomNode completed_node = std::move( stack->back() );
+      stack->pop_back();
+      stack->back().children.push_back( std::move( completed_node ) );
     }
+  }
 };
 } // namespace
 
-DomNode TreeBuilder::build(const std::vector<HtmlToken>& tokens) const // NOLINT(readability-convert-member-functions-to-static)
+DomNode TreeBuilder::build( // NOLINT(readability-convert-member-functions-to-static)
+  const std::vector<HtmlToken>& tokens ) const
 {
-    std::vector<DomNode> stack;
-    stack.emplace_back(DomNode{
-        .tag_name = "Document",
-        .text_content = "",
-        .children = {}
-    });
+  std::vector<DomNode> stack;
+  stack.emplace_back( DomNode { .tag_name = "Document", .text_content = "", .children = {} } );
 
-    TokenVisitor visitor{&stack};
-    for (const auto& token : tokens) {
-        std::visit(visitor, token);
-    }
+  TokenVisitor visitor { &stack };
+  for ( const auto& token : tokens ) {
+    std::visit( visitor, token );
+  }
 
-    while (stack.size() > 1) {
-        DomNode completed_node = std::move(stack.back());
-        stack.pop_back();
-        stack.back().children.push_back(std::move(completed_node));
-    }
+  while ( stack.size() > 1 ) {
+    DomNode completed_node = std::move( stack.back() );
+    stack.pop_back();
+    stack.back().children.push_back( std::move( completed_node ) );
+  }
 
-    return std::move(stack.front());
+  return std::move( stack.front() );
 }
 
 } // namespace ricochet::parser
\ No newline at end of file
-- 
cgit v1.2.3


From 85c1e247ce50ea1fa1ba12d524664063eac737a1 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Sat, 11 Apr 2026 03:40:54 +0800
Subject: feat: implement terminal renderer and integrate into browser core

---
 ricochet/include/ricochet/render/renderer.hh | 43 ++++++++++++++++++
 ricochet/src/core/browser.cc                 | 35 ++++++++-------
 ricochet/src/net/http_client.cc              |  3 +-
 ricochet/src/render/renderer.cc              | 65 ++++++++++++++++++++++++++++
 4 files changed, 129 insertions(+), 17 deletions(-)
 create mode 100644 ricochet/include/ricochet/render/renderer.hh
 create mode 100644 ricochet/src/render/renderer.cc

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/include/ricochet/render/renderer.hh b/ricochet/include/ricochet/render/renderer.hh
new file mode 100644
index 0000000..8a5c463
--- /dev/null
+++ b/ricochet/include/ricochet/render/renderer.hh
@@ -0,0 +1,43 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/parser/dom_tree.hh"
+
+namespace ricochet::render {
+
+class Renderer
+{
+public:
+  Renderer() = default;
+  ~Renderer() = default;
+
+  Renderer( const Renderer& ) = delete;
+  Renderer& operator=( const Renderer& ) = delete;
+  Renderer( Renderer&& ) = delete;
+  Renderer& operator=( Renderer&& ) = delete;
+
+  /**
+   * @brief Traverse the DOM tree and output the formatted result to the terminal using ANSI escape codes
+   * @param node The root node of the DOM tree
+   */
+  void render( const parser::DomNode& node ) const;
+};
+
+} // namespace ricochet::render
\ No newline at end of file
diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index e4c4c60..31f4df0 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -20,23 +20,24 @@
 #include "ricochet/net/http_client.hh"
 #include "ricochet/parser/html_lexer.hh"
 #include "ricochet/parser/tree_builder.hh"
+#include "ricochet/render/renderer.hh"
 #include <iostream>
 
-namespace {
-void print_dom_tree( const ricochet::parser::DomNode& node, std::size_t depth = 0 ) // NOLINT(misc-no-recursion)
-{
-  const std::string indent( depth * 2, ' ' );
+// namespace {
+// void print_dom_tree( const ricochet::parser::DomNode& node, std::size_t depth = 0 ) // NOLINT(misc-no-recursion)
+// {
+//   const std::string indent( depth * 2, ' ' );
 
-  if ( node.tag_name.empty() ) {
-    std::cout << indent << "\"" << node.text_content << "\"\n";
-  } else {
-    std::cout << indent << "<" << node.tag_name << ">\n";
-    for ( const auto& child : node.children ) {
-      print_dom_tree( child, depth + 1 );
-    }
-  }
-}
-} // namespace
+//   if ( node.tag_name.empty() ) {
+//     std::cout << indent << "\"" << node.text_content << "\"\n";
+//   } else {
+//     std::cout << indent << "<" << node.tag_name << ">\n";
+//     for ( const auto& child : node.children ) {
+//       print_dom_tree( child, depth + 1 );
+//     }
+//   }
+// }
+// } // namespace
 namespace ricochet::core {
 
 int Browser::run( std::string_view initial_url )
@@ -59,8 +60,10 @@ int Browser::run( std::string_view initial_url )
   const parser::TreeBuilder builder;
   const auto dom_root = builder.build( tokens );
 
-  std::cout << "\n[=== Abstract Syntax Tree (DOM) ===]\n";
-  print_dom_tree( dom_root );
+  // std::cout << "\033[2J\033[1;1H";
+
+  const render::Renderer renderer;
+  renderer.render( dom_root );
 
   return 0;
 }
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index d45de40..b31073c 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -59,7 +59,8 @@ std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
 }
 } // namespace
 
-std::expected<HttpResponse, std::string> HttpClient::fetch( // NOLINT(readability-convert-member-functions-to-static)
+std::expected<HttpResponse, std::string>
+HttpClient::fetch( // NOLINT(readability-convert-member-functions-to-static)
   std::string_view url ) const
 {
   auto parsed_url = parse_url( url );
diff --git a/ricochet/src/render/renderer.cc b/ricochet/src/render/renderer.cc
new file mode 100644
index 0000000..81c2be2
--- /dev/null
+++ b/ricochet/src/render/renderer.cc
@@ -0,0 +1,65 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/render/renderer.hh"
+#include <iostream>
+
+namespace ricochet::render {
+
+namespace {
+
+void render_node( const parser::DomNode& node ) // NOLINT(misc-no-recursion)
+{
+  if ( node.tag_name == "head" || node.tag_name == "style" || node.tag_name == "script" || node.tag_name == "meta"
+       || node.tag_name == "title" || node.tag_name == "link" ) {
+    return;
+  }
+
+  if ( node.tag_name.empty() ) {
+    std::cout << node.text_content;
+    return;
+  }
+  if ( node.tag_name == "h1" ) {
+    std::cout << "\n\n\033[1;31m";
+  } else if ( node.tag_name == "a" ) {
+    std::cout << "\033[4;34m";
+  } else if ( node.tag_name == "p" || node.tag_name == "div" ) {
+    std::cout << "\n";
+  }
+
+  for ( const auto& child : node.children ) {
+    render_node( child );
+  }
+  if ( node.tag_name == "h1" || node.tag_name == "a" ) {
+    std::cout << "\033[0m";
+  }
+
+  if ( node.tag_name == "h1" || node.tag_name == "p" || node.tag_name == "div" ) {
+    std::cout << "\n";
+  }
+}
+
+} // namespace
+
+void Renderer::render( const parser::DomNode& node ) const // NOLINT(readability-convert-member-functions-to-static)
+{
+  render_node( node );
+  std::cout << "\n";
+}
+
+} // namespace ricochet::render
\ No newline at end of file
-- 
cgit v1.2.3


From 12188f045a3f6ccce4359d946167066e3b584939 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Sat, 11 Apr 2026 05:36:22 +0800
Subject: feat: implement SSLSocket for encrypted connections and add terminal
 size detection utility

---
 ricochet/include/ricochet/net/ssl_socket.hh |  93 +++++++++++++++++++
 ricochet/include/ricochet/tui/terminal.hh   |  31 ++++---
 ricochet/src/core/browser.cc                |  32 ++++---
 ricochet/src/net/http_client.cc             | 135 ++++++++++++++++++++++++----
 ricochet/src/net/ssl_socket.cc              | 118 ++++++++++++++++++++++++
 ricochet/src/render/renderer.cc             |  38 ++++++--
 ricochet/src/tui/terminal.cc                |  71 +++++++++------
 7 files changed, 439 insertions(+), 79 deletions(-)
 create mode 100644 ricochet/include/ricochet/net/ssl_socket.hh
 create mode 100644 ricochet/src/net/ssl_socket.cc

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/include/ricochet/net/ssl_socket.hh b/ricochet/include/ricochet/net/ssl_socket.hh
new file mode 100644
index 0000000..36a92b6
--- /dev/null
+++ b/ricochet/include/ricochet/net/ssl_socket.hh
@@ -0,0 +1,93 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "sys/address.hh"
+#include "sys/socket.hh"
+#include <memory>
+#include <string>
+#include <string_view>
+
+extern "C" {
+using SSL_CTX = struct ssl_ctx_st;
+using SSL = struct ssl_st;
+}
+
+namespace ricochet::net {
+
+struct SslCtxDeleter
+{
+  void operator()( SSL_CTX* ptr ) const;
+};
+struct SslDeleter
+{
+  void operator()( SSL* ptr ) const;
+};
+
+using UniqueSslCtx = std::unique_ptr<SSL_CTX, SslCtxDeleter>;
+using UniqueSsl = std::unique_ptr<SSL, SslDeleter>;
+
+/**
+ * @brief Socket wrapper that supports TLS/SSL encrypted handshake
+ */
+class SSLSocket
+{
+public:
+  SSLSocket();
+  ~SSLSocket() = default;
+
+  SSLSocket( const SSLSocket& ) = delete;
+  SSLSocket& operator=( const SSLSocket& ) = delete;
+  SSLSocket( SSLSocket&& ) = delete;
+  SSLSocket& operator=( SSLSocket&& ) = delete;
+
+  /**
+   * @brief Connect to a remote host using TLS/SSL
+   * @param host The hostname to connect to
+   * @param port The port to connect to
+   * @return True if the connection was successful, false otherwise
+   */
+  void connect( const Address& address, const std::string& hostname );
+
+  /**
+   * @brief Send data over the TLS/SSL connection
+   * @param data The data to send
+   * @return The number of bytes sent, or -1 if an error occurred
+   */
+  std::size_t write( std::string_view data );
+
+  /**
+   * @brief Receive data from the TLS/SSL connection
+   * @param buffer The buffer to store the received data
+   */
+  void read( std::string& buffer );
+
+  /**
+   * @brief Check if the TLS/SSL connection is closed
+   * @return True if the connection is closed, false otherwise
+   */
+  bool eof() const;
+
+private:
+  TCPSocket underlying_socket_ {}; // TCP Socket
+  UniqueSslCtx ctx_ { nullptr };   // OpenSSL global context
+  UniqueSsl ssl_ { nullptr };      // Current connection's SSL state
+  bool eof_ { false };             // EOF flag
+};
+} // namespace ricochet::net
\ No newline at end of file
diff --git a/ricochet/include/ricochet/tui/terminal.hh b/ricochet/include/ricochet/tui/terminal.hh
index 5388845..59ca298 100644
--- a/ricochet/include/ricochet/tui/terminal.hh
+++ b/ricochet/include/ricochet/tui/terminal.hh
@@ -19,27 +19,32 @@
 #pragma once
 
 #include <termios.h>
+#include <utility>
 
 namespace ricochet::tui {
 
-class Terminal {
+class Terminal
+{
 public:
-    Terminal();
-    ~Terminal();
+  Terminal();
+  ~Terminal();
 
-    Terminal(const Terminal&) = delete;
-    Terminal& operator=(const Terminal&) = delete;
-    Terminal(Terminal&&) = delete;
-    Terminal& operator=(Terminal&&) = delete;
+  Terminal( const Terminal& ) = delete;
+  Terminal& operator=( const Terminal& ) = delete;
+  Terminal( Terminal&& ) = delete;
+  Terminal& operator=( Terminal&& ) = delete;
 
-    // Read a single key
-    char read_key() const;
-    
-    // Clear screen and move cursor to top-left
-    void clear_screen() const;
+  // Read a single key
+  char read_key() const;
+
+  // Clear screen and move cursor to top-left
+  void clear_screen() const;
+
+  // Get terminal size
+  std::pair<std::size_t, std::size_t> get_size() const;
 
 private:
-    struct termios original_termios_{}; // Save terminal original state
+  struct termios original_termios_ {}; // Save terminal original state
 };
 
 } // namespace ricochet::tui
\ No newline at end of file
diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index 0636de6..650ebcf 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -54,44 +54,48 @@ int Browser::run( std::string_view initial_url )
   const std::string rendered_text = renderer.render( dom_root );
 
   std::vector<std::string> lines;
-  std::stringstream ss(rendered_text);
+  std::stringstream ss( rendered_text );
   std::string line;
-  while (std::getline(ss, line, '\n')) {
-    lines.push_back(line);
+  while ( std::getline( ss, line, '\n' ) ) {
+    lines.push_back( line );
   }
 
+  std::cout << "DEBUG: Status Code: " << response.status_code << "\r\n";
+  std::cout << "DEBUG: Raw Body Length: " << response.body.length() << "\r\n";
+
   // TUI Event Loop
   const tui::Terminal terminal;
 
   std::size_t scroll_y = 0;
-  const std::size_t screen_height = 24;
 
-  while (true) {
+  while ( true ) {
     terminal.clear_screen();
 
-    for (std::size_t i = 0; i < screen_height - 1; ++i) {
+    const auto [term_width, term_height] = terminal.get_size();
+    const std::size_t usable_height = ( term_height > 1 ) ? ( term_height - 1 ) : 1;
+
+    for ( std::size_t i = 0; i < usable_height; ++i ) {
       const std::size_t line_idx = scroll_y + i;
-      if (line_idx < lines.size()) {
+      if ( line_idx < lines.size() ) {
         std::cout << lines[line_idx] << "\r\n";
       } else {
         std::cout << "~\r\n";
       }
     }
 
-    std::cout << "\033[7m" << " URL: " << initial_url 
-                  << " | [j] Down  [k] Up  [q] Quit " << "\033[0m";
+    std::cout << "\033[7m" << " URL: " << initial_url << " | [j] Down  [k] Up  [q] Quit " << "\033[0m";
     std::cout.flush();
 
     const char c = terminal.read_key();
-    if (c == 'q') {
+    if ( c == 'q' ) {
       break; // Break loop, terminal destructor will restore terminal
     }
-    if (c == 'j') {
-      if (scroll_y + screen_height - 1 < lines.size()) {
+    if ( c == 'j' ) {
+      if ( scroll_y + usable_height < lines.size() ) {
         scroll_y++; // Scroll down
       }
-    } else if (c == 'k') {
-      if (scroll_y > 0) {
+    } else if ( c == 'k' ) {
+      if ( scroll_y > 0 ) {
         scroll_y--; // Scroll up
       }
     }
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index b31073c..b31976f 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -17,6 +17,7 @@
  */
 
 #include "ricochet/net/http_client.hh"
+#include "ricochet/net/ssl_socket.hh"
 
 #include "ricochet/net/sys/address.hh"
 #include "ricochet/net/sys/socket.hh"
@@ -37,13 +38,17 @@ struct ParsedUrl
 
 std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
 {
-  const std::string_view http_prefix = "http://";
+  std::string_view prefix = "http://";
 
-  if ( !url.starts_with( http_prefix ) ) {
-    return std::unexpected( "Only 'http://' URLs are supported in MVP. (e.g., http://example.com)" );
+  if ( url.starts_with( "https://" ) ) {
+    prefix = "https://";
+  } else if ( url.starts_with( "http://" ) ) {
+    prefix = "http://";
+  } else {
+    return std::unexpected( "Only 'http://' or 'https://' URLs are supported." );
   }
 
-  url.remove_prefix( http_prefix.length() );
+  url.remove_prefix( prefix.length() );
   auto slash_pos = url.find( '/' );
 
   ParsedUrl result;
@@ -57,6 +62,77 @@ std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
 
   return result;
 }
+
+std::string dechunk( std::string_view body ) // NOLINT(readability-convert-member-functions-to-static)
+{
+  std::string result;
+  std::size_t pos = 0;
+  while ( pos < body.size() ) {
+    // find hex length end with \r\n
+    auto line_end = body.find( "\r\n", pos );
+    if ( line_end == std::string_view::npos ) {
+      break;
+    }
+
+    // parse hex length
+    const std::string len_str( body.substr( pos, line_end - pos ) );
+    unsigned int chunk_size = 0;
+    try {
+      chunk_size = std::stoul( len_str, nullptr, 16 );
+    } catch ( ... ) {
+      break;
+    }
+
+    if ( chunk_size == 0 ) {
+      break; // end of stream
+    }
+
+    // extract data block (skip \r\n)
+    pos = line_end + 2;
+    if ( pos + chunk_size > body.size() ) {
+      break;
+    }
+    result.append( body.substr( pos, chunk_size ) );
+
+    // skip data block's \r\n
+    pos += chunk_size + 2;
+  }
+  return result;
+}
+
+std::string remove_html_comments( std::string html ) // NOLINT(readability-convert-member-functions-to-static)
+{
+  std::size_t start_pos = 0;
+  while ( ( start_pos = html.find( "<!--", start_pos ) ) != std::string::npos ) {
+    auto end_pos = html.find( "-->", start_pos );
+    if ( end_pos != std::string::npos ) {
+      html.erase( start_pos, end_pos - start_pos + 3 );
+    } else {
+      html.erase( start_pos );
+      break;
+    }
+  }
+  return html;
+}
+
+std::string remove_tag_blocks( std::string html, const std::string& tag_name ) // NOLINT
+{
+  const std::string open_tag = "<" + tag_name;
+  const std::string close_tag = "</" + tag_name + ">";
+  std::size_t start_pos = 0;
+
+  while ( ( start_pos = html.find( open_tag, start_pos ) ) != std::string::npos ) {
+    const std::size_t end_pos = html.find( close_tag, start_pos );
+    if ( end_pos != std::string::npos ) {
+      html.erase( start_pos, end_pos - start_pos + close_tag.length() );
+    } else {
+      html.erase( start_pos );
+      break;
+    }
+  }
+  return html;
+}
+
 } // namespace
 
 std::expected<HttpResponse, std::string>
@@ -69,30 +145,46 @@ HttpClient::fetch( // NOLINT(readability-convert-member-functions-to-static)
   }
 
   auto [host, path] = parsed_url.value();
+  const bool is_https = url.starts_with( "https://" );
+  const std::string service = is_https ? "https" : "http";
 
   try {
-    const Address server_addr( host, "http" );
-
-    TCPSocket socket;
-    socket.connect( server_addr );
+    const Address server_addr( host, service );
 
     const std::string request = std::format( "GET {} HTTP/1.1\r\n"
                                              "Host: {}\r\n"
-                                             "User-Agent: Ricochet/0.1.0\r\n"
+                                             "User-Agent: Mozilla/5.0 (Ricochet/0.1.0)\r\n"
+                                             "Accept: text/html\r\n"
+                                             "Accept-Encoding: identity\r\n"
                                              "Connection: close\r\n\r\n",
                                              path,
                                              host );
 
-    size_t bytes_written = 0;
-    while ( bytes_written < request.size() ) {
-      bytes_written += socket.write( request.substr( bytes_written ) );
-    }
-
     std::string raw_response;
-    while ( !socket.eof() ) {
-      std::string buffer;
-      socket.read( buffer );
-      raw_response += buffer;
+    if ( is_https ) {
+      SSLSocket ssl_socket;
+      ssl_socket.connect( server_addr, host );
+      size_t bytes_written = 0;
+      while ( bytes_written < request.size() ) {
+        bytes_written += ssl_socket.write( request.substr( bytes_written ) );
+      }
+      while ( !ssl_socket.eof() ) {
+        std::string buffer;
+        ssl_socket.read( buffer );
+        raw_response += buffer;
+      }
+    } else {
+      TCPSocket tcp_socket;
+      tcp_socket.connect( server_addr );
+      size_t bytes_written = 0;
+      while ( bytes_written < request.size() ) {
+        bytes_written += tcp_socket.write( request.substr( bytes_written ) );
+      }
+      while ( !tcp_socket.eof() ) {
+        std::string buffer;
+        tcp_socket.read( buffer );
+        raw_response += buffer;
+      }
     }
 
     HttpResponse response;
@@ -111,6 +203,13 @@ HttpClient::fetch( // NOLINT(readability-convert-member-functions-to-static)
       response.body = raw_response;
     }
 
+    if ( raw_response.contains( "Transfer-Encoding: chunked" ) ) {
+      response.body = dechunk( response.body );
+    }
+
+    response.body = remove_html_comments( response.body );
+    response.body = remove_tag_blocks( response.body, "script" );
+    response.body = remove_tag_blocks( response.body, "style" );
     return response;
   } catch ( const std::exception& e ) {
     return std::unexpected( std::string( "Network Error: " ) + e.what() );
diff --git a/ricochet/src/net/ssl_socket.cc b/ricochet/src/net/ssl_socket.cc
new file mode 100644
index 0000000..a31b564
--- /dev/null
+++ b/ricochet/src/net/ssl_socket.cc
@@ -0,0 +1,118 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/net/ssl_socket.hh"
+#include <iostream>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <stdexcept>
+
+namespace ricochet::net {
+
+// --- RAII Deleters ---
+
+void SslCtxDeleter::operator()( SSL_CTX* ptr ) const
+{
+  if ( ptr != nullptr ) {
+    SSL_CTX_free( ptr );
+  }
+}
+
+void SslDeleter::operator()( SSL* ptr ) const
+{
+  if ( ptr != nullptr ) {
+    SSL_free( ptr );
+  }
+}
+
+// SSLSocket Implementation
+
+SSLSocket::SSLSocket()
+{
+  const SSL_METHOD* method = TLS_client_method();
+  ctx_.reset( SSL_CTX_new( method ) );
+  if ( !ctx_ ) {
+    throw std::runtime_error( "Failed to create SSL_CTX" );
+  }
+
+  if ( SSL_CTX_set_default_verify_paths( ctx_.get() ) != 1 ) {
+    throw std::runtime_error( "Failed to load default CA certificates" );
+  }
+}
+
+void SSLSocket::connect( const Address& address, const std::string& hostname )
+{
+  // TCP Connect
+  underlying_socket_.connect( address );
+
+  ssl_.reset( SSL_new( ctx_.get() ) );
+  if ( !ssl_ ) {
+    throw std::runtime_error( "Failed to create SSL object" );
+  }
+
+  // Setup SNI (Server Name Indication)
+  if ( SSL_set_tlsext_host_name( ssl_.get(), hostname.c_str() ) != 1 ) {
+    // Some old servers do not support SNI, here we can ignore the error or throw an exception, depending on the
+    // requirements
+    std::cerr << "Warning: Failed to set SNI" << '\n';
+  }
+
+  SSL_set_fd( ssl_.get(), underlying_socket_.fd_num() );
+
+  if ( SSL_connect( ssl_.get() ) != 1 ) {
+    throw std::runtime_error( "TLS Handshake failed!" );
+  }
+}
+
+std::size_t SSLSocket::write( std::string_view data )
+{
+  if ( !ssl_ ) {
+    return 0;
+  }
+
+  const int bytes_written = SSL_write( ssl_.get(), data.data(), static_cast<int>( data.size() ) );
+  if ( bytes_written <= 0 ) {
+    throw std::runtime_error( "SSL write failed" );
+  }
+  return static_cast<std::size_t>( bytes_written );
+}
+
+void SSLSocket::read( std::string& buffer )
+{
+  if ( !ssl_ ) {
+    return;
+  }
+
+  std::array<char, 4096> buf {};
+  // Read decrypted data from the encrypted channel
+  const int bytes_read = SSL_read( ssl_.get(), buf.data(), static_cast<int>( buf.size() ) );
+
+  if ( bytes_read > 0 ) {
+    buffer.append( buf.data(), static_cast<std::size_t>( bytes_read ) );
+  } else {
+    // Read 0 or negative, representing the server closed the connection (EOF)
+    eof_ = true;
+  }
+}
+
+bool SSLSocket::eof() const
+{
+  return eof_;
+}
+
+} // namespace ricochet::net
\ No newline at end of file
diff --git a/ricochet/src/render/renderer.cc b/ricochet/src/render/renderer.cc
index 0a91d49..2115ee1 100644
--- a/ricochet/src/render/renderer.cc
+++ b/ricochet/src/render/renderer.cc
@@ -23,6 +23,25 @@ namespace ricochet::render {
 
 namespace {
 
+std::string decode_entities( std::string text ) // NOLINT(readability-convert-member-functions-to-static)
+{
+  constexpr std::array<std::pair<std::string_view, std::string_view>, 24> entities
+    = { { { "&nbsp;", " " },   { "&lt;", "<" },     { "&gt;", ">" },    { "&amp;", "&" },   { "&quot;", "\"" },
+          { "&copy;", "©" },   { "&reg;", "®" },    { "&trade;", "™" }, { "&euro;", "€" },  { "&pound;", "£" },
+          { "&yen;", "¥" },    { "&cent;", "¢" },   { "&sect;", "§" },  { "&para;", "¶" },  { "&hellip;", "…" },
+          { "&dagger;", "†" }, { "&Dagger;", "‡" }, { "&bull;", "•" },  { "&prime;", "′" }, { "&Prime;", "″" },
+          { "&lsaquo;", "‹" }, { "&rsaquo;", "›" }, { "&oline;", "‾" }, { "&frasl;", "⁄" } } };
+
+  for ( const auto& [entity, replacement] : entities ) {
+    std::size_t pos = 0;
+    while ( ( pos = text.find( entity, pos ) ) != std::string::npos ) {
+      text.replace( pos, entity.length(), replacement );
+      pos += replacement.length();
+    }
+  }
+  return text;
+}
+
 void render_node( const parser::DomNode& node, std::string& output ) // NOLINT(misc-no-recursion)
 {
   if ( node.tag_name == "head" || node.tag_name == "style" || node.tag_name == "script" || node.tag_name == "meta"
@@ -31,21 +50,27 @@ void render_node( const parser::DomNode& node, std::string& output ) // NOLINT(m
   }
 
   if ( node.tag_name.empty() ) {
-    output += node.text_content;
+    output += decode_entities( node.text_content );
     return;
   }
-  if ( node.tag_name == "h1" ) {
+
+  const bool is_header
+    = ( node.tag_name == "h1" || node.tag_name == "h2" || node.tag_name == "h3" || node.tag_name == "h4" );
+
+  if ( is_header ) {
     output += "\n\n\033[1;31m";
   } else if ( node.tag_name == "a" ) {
     std::cout << "\033[4;34m";
-  } else if ( node.tag_name == "p" || node.tag_name == "div" ) {
-    output += "\n";
+  } else if ( node.tag_name == "p" || node.tag_name == "div" || is_header ) {
+    if ( !output.empty() && output.back() != '\n' ) {
+      output += "\n";
+    }
   }
 
   for ( const auto& child : node.children ) {
     render_node( child, output );
   }
-  if ( node.tag_name == "h1" || node.tag_name == "a" ) {
+  if ( is_header || node.tag_name == "a" ) {
     output += "\033[0m";
   }
 
@@ -56,7 +81,8 @@ void render_node( const parser::DomNode& node, std::string& output ) // NOLINT(m
 
 } // namespace
 
-std::string Renderer::render( const parser::DomNode& node ) const // NOLINT(readability-convert-member-functions-to-static)
+std::string Renderer::render( // NOLINT(readability-convert-member-functions-to-static)
+  const parser::DomNode& node ) const
 {
   std::string output;
   render_node( node, output );
diff --git a/ricochet/src/tui/terminal.cc b/ricochet/src/tui/terminal.cc
index 8fdb585..75c6c1f 100644
--- a/ricochet/src/tui/terminal.cc
+++ b/ricochet/src/tui/terminal.cc
@@ -19,44 +19,59 @@
 #include "ricochet/tui/terminal.hh"
 #include <cstdlib>
 #include <iostream>
+#include <sys/ioctl.h>
 #include <unistd.h>
 
 namespace ricochet::tui {
 
-Terminal::Terminal() {
-    // get terminal attributes
-    tcgetattr(STDIN_FILENO, &original_termios_);
-    
-    struct termios raw = original_termios_;
-    
-    // close echo, close canonical mode
-    // close terminal signals (ISIG disable Ctrl+C and Ctrl+Z, let the program handle it)
-    raw.c_lflag &= ~(ECHO | ICANON | ISIG);
-    
-    // close software flow control (Ctrl+S, Ctrl+Q)
-    raw.c_iflag &= ~(IXON | ICRNL);
-    
-    // apply new terminal attributes
-    tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
+Terminal::Terminal()
+{
+  // get terminal attributes
+  tcgetattr( STDIN_FILENO, &original_termios_ );
+
+  struct termios raw = original_termios_;
+
+  // close echo, close canonical mode
+  // close terminal signals (ISIG disable Ctrl+C and Ctrl+Z, let the program handle it)
+  raw.c_lflag &= ~( ECHO | ICANON | ISIG );
+
+  // close software flow control (Ctrl+S, Ctrl+Q)
+  raw.c_iflag &= ~( IXON | ICRNL );
+
+  // apply new terminal attributes
+  tcsetattr( STDIN_FILENO, TCSAFLUSH, &raw );
+}
+
+Terminal::~Terminal()
+{
+  // RAII: restore terminal attributes when program exits
+  tcsetattr( STDIN_FILENO, TCSAFLUSH, &original_termios_ );
 }
 
-Terminal::~Terminal() {
-    // RAII: restore terminal attributes when program exits
-    tcsetattr(STDIN_FILENO, TCSAFLUSH, &original_termios_);
+char Terminal::read_key() const // NOLINT(readability-convert-member-functions-to-static)
+{
+  char c = '\0';
+  // read 1 byte
+  if ( read( STDIN_FILENO, &c, 1 ) == -1 ) {
+    return '\0';
+  }
+  return c;
 }
 
-char Terminal::read_key() const { // NOLINT(readability-convert-member-functions-to-static)
-    char c = '\0';
-    // read 1 byte
-    if (read(STDIN_FILENO, &c, 1) == -1) {
-        return '\0';
-    }
-    return c;
+void Terminal::clear_screen() const // NOLINT(readability-convert-member-functions-to-static)
+{
+  // ANSI escape codes: \x1b[2J clear screen, \x1b[H move cursor to (1,1)
+  std::cout << "\x1b[2J\x1b[H";
 }
 
-void Terminal::clear_screen() const { // NOLINT(readability-convert-member-functions-to-static)
-    // ANSI escape codes: \x1b[2J clear screen, \x1b[H move cursor to (1,1)
-    std::cout << "\x1b[2J\x1b[H";
+std::pair<std::size_t, std::size_t> Terminal::get_size() // NOLINT(readability-convert-member-functions-to-static)
+  const
+{
+  struct winsize w {};
+  if ( ioctl( STDOUT_FILENO, TIOCGWINSZ, &w ) == -1 ) {
+    return { 80, 24 };
+  }
+  return { static_cast<std::size_t>( w.ws_col ), static_cast<std::size_t>( w.ws_row ) };
 }
 
 } // namespace ricochet::tui
\ No newline at end of file
-- 
cgit v1.2.3


From 79ab6fcb6e74109c46e836594b2cc1ead87d7b30 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Sun, 12 Apr 2026 16:43:23 +0800
Subject: feat: implement HTTP redirect support, URL search formatting, image
 alt text rendering, and improved terminal cursor management

---
 ricochet/src/core/browser.cc    | 131 +++++++++++++++++++++++++++++++---------
 ricochet/src/main.cc            |   7 ++-
 ricochet/src/net/http_client.cc | 126 +++++++++++++++++++++++++++-----------
 ricochet/src/render/renderer.cc |  16 ++++-
 ricochet/src/tui/terminal.cc    |   1 +
 5 files changed, 214 insertions(+), 67 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index 8bd921c..2968ab1 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -80,10 +80,34 @@ void draw_view( const tui::Terminal& terminal,
       std::cout << "~\r\n";
     }
   }
-  std::cout << "\033[7m URL: " << url << " | [j/k] Scroll [/] Jump [f] Follow [q] Quit \033[0m";
+  std::cout << "\033[7m URL: " << url << " | [j/k] Scroll [/] Jump [f] Follow [H/L] History [q] Quit \033[0m";
   std::cout.flush();
 }
 
+std::string format_url( std::string input )
+{
+  if ( input.empty() ) {
+    return input;
+  }
+
+  if ( input.starts_with( "http://" ) || input.starts_with( "https://" ) ) {
+    return input;
+  }
+
+  const bool is_domain = input.contains( '.' ) && !input.contains( ' ' );
+  if ( is_domain ) {
+    input.insert( 0, "https://" );
+    return input;
+  }
+
+  for ( char& ch : input ) {
+    if ( ch == ' ' ) {
+      ch = '+';
+    }
+  }
+  return "https://lite.duckduckgo.com/lite/?q=" + input;
+}
+
 std::string get_url_input( const tui::Terminal& terminal )
 {
   auto [width, height] = terminal.get_size();
@@ -116,10 +140,7 @@ std::string get_url_input( const tui::Terminal& terminal )
   }
   terminal.show_cursor( false );
 
-  if ( !input.empty() && !input.starts_with( "http://" ) && !input.starts_with( "https://" ) ) {
-    input.insert( 0, "https://" );
-  }
-  return input;
+  return format_url( std::move( input ) );
 }
 
 std::string get_link_input( const tui::Terminal& terminal )
@@ -195,50 +216,100 @@ void handle_follow_link( const tui::Terminal& terminal,
   }
 }
 
+enum class InputAction : std::uint8_t
+{
+  None,
+  Quit,
+  Navigate
+};
+
+InputAction process_key( char c,
+                         const tui::Terminal& terminal,
+                         const PageData& page_data,
+                         std::string& current_url,
+                         std::vector<std::string>& history,
+                         std::size_t& history_idx, // NOLINT(bugprone-easily-swappable-parameters)
+                         std::size_t& scroll_y )   // NOLINT(bugprone-easily-swappable-parameters)
+{
+  auto [width, height] = terminal.get_size();
+  const std::size_t view_h = ( height > 1 ) ? ( height - 1 ) : 1;
+
+  if ( c == 'q' ) {
+    return InputAction::Quit;
+  }
+  if ( c == 'j' && scroll_y + view_h < page_data.lines.size() ) {
+    scroll_y++;
+  }
+  if ( c == 'k' && scroll_y > 0 ) {
+    scroll_y--;
+  }
+  if ( c == 'H' && history_idx > 0 ) {
+    history_idx--;
+    return InputAction::Navigate;
+  }
+  if ( c == 'L' && history_idx + 1 < history.size() ) {
+    history_idx++;
+    return InputAction::Navigate;
+  }
+
+  if ( c == '/' ) {
+    const std::string next_url = get_url_input( terminal );
+    if ( !next_url.empty() ) {
+      history.resize( history_idx + 1 );
+      history.push_back( next_url );
+      history_idx++;
+      return InputAction::Navigate;
+    }
+  }
+
+  if ( c == 'f' ) {
+    const std::string old_url = current_url;
+    bool nav = false;
+    handle_follow_link( terminal, page_data.links, current_url, nav );
+    if ( nav && current_url != old_url ) {
+      history.resize( history_idx + 1 );
+      history.push_back( current_url );
+      history_idx++;
+      return InputAction::Navigate;
+    }
+  }
+  return InputAction::None;
+}
+
 } // namespace
 
 int Browser::run( std::string_view initial_url )
 {
-  std::cout << "-> Fetching: " << initial_url << "...\n";
-
-  std::string current_url { initial_url };
+  std::vector<std::string> history;
+  history.emplace_back( initial_url );
+  std::size_t history_idx = 0;
   const tui::Terminal terminal;
-  terminal.clear_screen();
+  terminal.show_cursor( false );
+
+  while ( true ) {
+    std::string current_url = history[history_idx];
+    terminal.clear_screen();
+    std::cout << "-> Fetching: " << current_url << "...\r\n";
+    std::cout.flush();
 
-  while ( !current_url.empty() ) {
     auto page_data = load_page( current_url );
-    const auto& lines = page_data.lines;
-    const auto& links = page_data.links;
     std::size_t scroll_y = 0;
     bool navigate = false;
 
     while ( !navigate ) {
-      draw_view( terminal, lines, scroll_y, current_url );
-
+      draw_view( terminal, page_data.lines, scroll_y, current_url );
       const char c = terminal.read_key();
-      auto [width, height] = terminal.get_size();
-      const std::size_t view_h = ( height > 1 ) ? ( height - 1 ) : 1;
 
-      if ( c == 'q' ) {
+      const InputAction action = process_key( c, terminal, page_data, current_url, history, history_idx, scroll_y );
+      if ( action == InputAction::Quit ) {
         terminal.clear_screen();
         return 0;
       }
-      if ( c == 'j' && scroll_y + view_h < lines.size() ) {
-        scroll_y++;
-      } else if ( c == 'k' && scroll_y > 0 ) {
-        scroll_y--;
-      } else if ( c == '/' ) {
-        std::string next_url = get_url_input( terminal );
-        if ( !next_url.empty() ) {
-          current_url = std::move( next_url );
-          navigate = true;
-        }
-      } else if ( c == 'f' ) {
-        handle_follow_link( terminal, links, current_url, navigate );
+      if ( action == InputAction::Navigate ) {
+        navigate = true;
       }
     }
   }
-
   terminal.clear_screen();
   return 0;
 }
diff --git a/ricochet/src/main.cc b/ricochet/src/main.cc
index 0371cda..1037833 100644
--- a/ricochet/src/main.cc
+++ b/ricochet/src/main.cc
@@ -62,8 +62,13 @@ int main( int argc, char* argv[] )
     return 0;
   }
 
+  std::string start_url( input );
+  if ( !start_url.starts_with( "http://" ) && !start_url.starts_with( "https://" ) ) {
+    start_url.insert( 0, "https://" );
+  }
+
   try {
-    return ricochet::core::Browser::run( input );
+    return ricochet::core::Browser::run( start_url );
   } catch ( const std::exception& e ) {
     std::cerr << "Critical Error: " << e.what() << "\n";
     return 1;
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index b31976f..5cf6a30 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -133,63 +133,111 @@ std::string remove_tag_blocks( std::string html, const std::string& tag_name ) /
   return html;
 }
 
-} // namespace
-
-std::expected<HttpResponse, std::string>
-HttpClient::fetch( // NOLINT(readability-convert-member-functions-to-static)
-  std::string_view url ) const
+std::string extract_redirect_url( const std::string& raw_response, bool is_https, const std::string& host )
 {
-  auto parsed_url = parse_url( url );
-  if ( !parsed_url.has_value() ) {
-    return std::unexpected( parsed_url.error() );
+  auto loc_pos = raw_response.find( "Location: " );
+  if ( loc_pos == std::string::npos ) {
+    loc_pos = raw_response.find( "location: " );
   }
+  if ( loc_pos != std::string::npos ) {
+    loc_pos += 10;
+    auto end_pos = raw_response.find( '\r', loc_pos );
+    if ( end_pos == std::string::npos ) {
+      end_pos = raw_response.find( '\n', loc_pos );
+    }
+    if ( end_pos != std::string::npos ) {
+      std::string next_url = raw_response.substr( loc_pos, end_pos - loc_pos );
+      while ( !next_url.empty() && std::isspace( static_cast<unsigned char>( next_url.front() ) ) ) {
+        next_url.erase( 0, 1 );
+      }
+      if ( next_url.starts_with( "/" ) ) {
+        next_url = ( is_https ? "https://" : "http://" ) + host + next_url;
+      }
+      return next_url;
+    }
+  }
+  return "";
+}
 
-  auto [host, path] = parsed_url.value();
-  const bool is_https = url.starts_with( "https://" );
-  const std::string service = is_https ? "https" : "http";
-
+struct FetchResult
+{
+  std::string raw_response {};
+  std::string error {};
+};
+FetchResult do_network_request( const std::string& host,
+                                const std::string& service, // NOLINT(bugprone-easily-swappable-parameters)
+                                const std::string& path,    // NOLINT(bugprone-easily-swappable-parameters)
+                                bool is_https )
+{
+  FetchResult res;
   try {
     const Address server_addr( host, service );
+    const std::string request
+      = std::format( "GET {} HTTP/1.1\r\n"
+                     "Host: {}\r\n"
+                     "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
+                     "Chrome/124.0.0.0 Safari/537.36\r\n"
+                     "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
+                     "Accept-Language: en-US,en;q=0.9\r\n"
+                     "DNT: 1\r\n"
+                     "Connection: close\r\n\r\n",
+                     path,
+                     host );
 
-    const std::string request = std::format( "GET {} HTTP/1.1\r\n"
-                                             "Host: {}\r\n"
-                                             "User-Agent: Mozilla/5.0 (Ricochet/0.1.0)\r\n"
-                                             "Accept: text/html\r\n"
-                                             "Accept-Encoding: identity\r\n"
-                                             "Connection: close\r\n\r\n",
-                                             path,
-                                             host );
-
-    std::string raw_response;
     if ( is_https ) {
       SSLSocket ssl_socket;
       ssl_socket.connect( server_addr, host );
-      size_t bytes_written = 0;
-      while ( bytes_written < request.size() ) {
-        bytes_written += ssl_socket.write( request.substr( bytes_written ) );
+      for ( size_t bw = 0; bw < request.size(); ) {
+        bw += ssl_socket.write( request.substr( bw ) );
       }
       while ( !ssl_socket.eof() ) {
         std::string buffer;
         ssl_socket.read( buffer );
-        raw_response += buffer;
+        res.raw_response += buffer;
       }
     } else {
       TCPSocket tcp_socket;
       tcp_socket.connect( server_addr );
-      size_t bytes_written = 0;
-      while ( bytes_written < request.size() ) {
-        bytes_written += tcp_socket.write( request.substr( bytes_written ) );
+      for ( size_t bw = 0; bw < request.size(); ) {
+        bw += tcp_socket.write( request.substr( bw ) );
       }
       while ( !tcp_socket.eof() ) {
         std::string buffer;
         tcp_socket.read( buffer );
-        raw_response += buffer;
+        res.raw_response += buffer;
       }
     }
+  } catch ( const std::exception& e ) {
+    res.error = std::string( "Network Error: " ) + e.what();
+  }
+  return res;
+}
 
-    HttpResponse response;
-    auto header_end = raw_response.find( "\r\n\r\n" );
+} // namespace
+
+std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url ) const
+{
+  (void)this; // 完美绕过 static 方法警告，满足最严苛的 tidy 规则
+  std::string current_url( url );
+
+  for ( int redirect_count = 0; redirect_count < 5; ++redirect_count ) {
+    const auto parsed_url = parse_url( current_url );
+    if ( !parsed_url.has_value() ) {
+      return std::unexpected( parsed_url.error() );
+    }
+
+    const auto [host, path] = parsed_url.value();
+    const bool is_https = current_url.starts_with( "https://" );
+    const std::string service = is_https ? "https" : "http";
+
+    const FetchResult net_res = do_network_request( host, service, path, is_https );
+    if ( !net_res.error.empty() ) {
+      return std::unexpected( net_res.error );
+    }
+    const std::string& raw_response = net_res.raw_response;
 
+    HttpResponse response;
+    const auto header_end = raw_response.find( "\r\n\r\n" );
     if ( header_end != std::string::npos ) {
       response.body = raw_response.substr( header_end + 4 );
       if ( raw_response.size() >= 12 ) {
@@ -201,19 +249,27 @@ HttpClient::fetch( // NOLINT(readability-convert-member-functions-to-static)
       }
     } else {
       response.body = raw_response;
+      response.status_code = 0;
+    }
+
+    if ( response.status_code >= 300 && response.status_code < 400 ) {
+      const std::string next_url = extract_redirect_url( raw_response, is_https, host );
+      if ( !next_url.empty() ) {
+        current_url = next_url;
+        continue;
+      }
     }
 
     if ( raw_response.contains( "Transfer-Encoding: chunked" ) ) {
       response.body = dechunk( response.body );
     }
-
     response.body = remove_html_comments( response.body );
     response.body = remove_tag_blocks( response.body, "script" );
     response.body = remove_tag_blocks( response.body, "style" );
     return response;
-  } catch ( const std::exception& e ) {
-    return std::unexpected( std::string( "Network Error: " ) + e.what() );
   }
+
+  return std::unexpected( "Too many redirects" );
 }
 
 } // namespace ricochet::net
\ No newline at end of file
diff --git a/ricochet/src/render/renderer.cc b/ricochet/src/render/renderer.cc
index 1af40f1..2b690ca 100644
--- a/ricochet/src/render/renderer.cc
+++ b/ricochet/src/render/renderer.cc
@@ -83,11 +83,14 @@ void render_node( const parser::DomNode& node, // NOLINT(misc-no-recursion)
 
   const bool is_header = ( base_tag == "h1" || base_tag == "h2" || base_tag == "h3" || base_tag == "h4" );
   const bool is_link = ( base_tag == "a" );
+  const bool is_list_item = ( base_tag == "li" );
 
   if ( is_header ) {
     output += "\n\n\033[1;31m";
   } else if ( is_link ) {
-    output += "\033[4;34m"; // 【核心修复】：必须是 output += ，绝对不能用 std::cout
+    output += "\033[4;34m";
+  } else if ( is_list_item ) {
+    output += "\n  • ";
   } else if ( base_tag == "p" || base_tag == "div" || is_header ) {
     if ( !output.empty() && output.back() != '\n' ) {
       output += "\n";
@@ -112,6 +115,17 @@ void render_node( const parser::DomNode& node, // NOLINT(misc-no-recursion)
   if ( base_tag == "h1" || base_tag == "p" || base_tag == "div" ) {
     output += "\n";
   }
+
+  if ( base_tag == "img" ) {
+    std::size_t alt_pos = node.tag_name.find( "alt=\"" );
+    if ( alt_pos != std::string::npos ) {
+      alt_pos += 5;
+      const std::size_t alt_end = node.tag_name.find( '"', alt_pos );
+      output += " \033[90m[Image: " + node.tag_name.substr( alt_pos, alt_end - alt_pos ) + "]\033[0m ";
+    } else {
+      output += " \033[90m[IMAGE]\033[0m ";
+    }
+  }
 }
 
 } // namespace
diff --git a/ricochet/src/tui/terminal.cc b/ricochet/src/tui/terminal.cc
index 9e78a02..44c0f3b 100644
--- a/ricochet/src/tui/terminal.cc
+++ b/ricochet/src/tui/terminal.cc
@@ -44,6 +44,7 @@ Terminal::Terminal()
 
 Terminal::~Terminal()
 {
+  show_cursor( true );
   // RAII: restore terminal attributes when program exits
   tcsetattr( STDIN_FILENO, TCSAFLUSH, &original_termios_ );
 }
-- 
cgit v1.2.3


From 54adacb8316bd23f27265751e9ac8ef35b9ec892 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Sun, 12 Apr 2026 20:05:05 +0800
Subject: feat: add page title extraction, URL normalization, DuckDuckGo
 tracker stripping, and text wrapping support

---
 ricochet/src/core/browser.cc    | 188 +++++++++++++++++++++++++++++++++++-----
 ricochet/src/net/http_client.cc |  14 +--
 ricochet/src/render/renderer.cc |  43 +++++++--
 3 files changed, 208 insertions(+), 37 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index 2968ab1..4c42bd0 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -25,6 +25,7 @@
 #include <cstddef>
 #include <exception>
 #include <iostream>
+#include <ranges>
 
 namespace ricochet::core {
 
@@ -32,15 +33,57 @@ struct PageData
 {
   std::vector<std::string> lines;
   std::vector<std::string> links;
+  std::string title;
 };
 
 namespace {
+
+std::string extract_title( const parser::DomNode& root_node )
+{
+  std::vector<const parser::DomNode*> stack;
+  stack.push_back( &root_node );
+
+  while ( !stack.empty() ) {
+    const parser::DomNode* current = stack.back();
+    stack.pop_back();
+
+    std::string base_tag = current->tag_name;
+    const std::size_t space_pos = base_tag.find( ' ' );
+    if ( space_pos != std::string::npos ) {
+      base_tag = base_tag.substr( 0, space_pos );
+    }
+
+    for ( char& c : base_tag ) {
+      if ( c >= 'A' && c <= 'Z' ) {
+        c = static_cast<char>( c + 32 );
+      }
+    }
+
+    if ( base_tag == "title" ) {
+      std::string full_title;
+      for ( const auto& child : current->children ) {
+        if ( child.tag_name.empty() ) {
+          full_title += child.text_content;
+        }
+      }
+      if ( !full_title.empty() ) {
+        return full_title;
+      }
+    }
+
+    for ( const auto& child : std::ranges::reverse_view( current->children ) ) {
+      stack.push_back( &child );
+    }
+  }
+  return "";
+}
+
 PageData load_page( std::string_view url )
 {
   const net::HttpClient client;
   auto response_result = client.fetch( url );
   if ( !response_result.has_value() ) {
-    return { .lines = { "[!] Failed to load: " + std::string( url ) }, .links = {} };
+    return { .lines = { "[!] Failed to load: " + std::string( url ) }, .links = {}, .title = "Error" };
   }
 
   const parser::HtmlLexer lexer;
@@ -61,17 +104,40 @@ PageData load_page( std::string_view url )
     lines.push_back( result.text.substr( start, end - start ) );
     start = end + 1;
   }
-  return { .lines = lines, .links = result.links };
+  const std::string title = extract_title( dom_root );
+  return { .lines = lines, .links = result.links, .title = title };
 }
 
 void draw_view( const tui::Terminal& terminal,
                 const std::vector<std::string>& lines,
                 std::size_t scroll_y,
-                std::string_view url )
+                std::string_view url,    // NOLINT(bugprone-easily-swappable-parameters)
+                std::string_view title ) // NOLINT(bugprone-easily-swappable-parameters)
 {
   terminal.clear_screen();
   auto [width, height] = terminal.get_size();
-  const std::size_t usable_height = ( height > 1 ) ? ( height - 1 ) : 1;
+  const std::size_t usable_height = ( height > 2 ) ? ( height - 2 ) : 1;
+
+  std::string clean_title( title );
+  if ( clean_title.empty() ) {
+    const std::size_t start = url.find( "://" );
+    const std::size_t host_start = ( start == std::string::npos ) ? 0 : start + 3;
+    const std::size_t host_end = url.find( '/', host_start );
+    clean_title = std::string( url.substr( host_start, host_end - host_start ) );
+  }
+  for ( char& c : clean_title ) {
+    if ( c == '\n' || c == '\r' ) {
+      c = ' ';
+    }
+  }
+
+  std::string header = " PAGE: " + clean_title;
+  if ( header.size() < width ) {
+    header.append( width - header.size(), ' ' );
+  } else if ( header.size() > width && width > 3 ) {
+    header = header.substr( 0, width - 3 ) + "...";
+  }
+  std::cout << "\033[7m" << header << "\033[0m\r\n";
 
   for ( std::size_t i = 0; i < usable_height; ++i ) {
     if ( scroll_y + i < lines.size() ) {
@@ -80,7 +146,14 @@ void draw_view( const tui::Terminal& terminal,
       std::cout << "~\r\n";
     }
   }
-  std::cout << "\033[7m URL: " << url << " | [j/k] Scroll [/] Jump [f] Follow [H/L] History [q] Quit \033[0m";
+
+  std::string footer = " URL: " + std::string( url ) + " | [j/k]Scroll [/]Jump [f]Follow [H/L]History [q]Quit ";
+  if ( footer.size() < width ) {
+    footer.append( width - footer.size(), ' ' );
+  } else if ( footer.size() > width && width > 3 ) {
+    footer = footer.substr( 0, width - 3 ) + "...";
+  }
+  std::cout << "\033[7m" << footer << "\033[0m";
   std::cout.flush();
 }
 
@@ -177,6 +250,52 @@ std::string get_link_input( const tui::Terminal& terminal )
   return num_input;
 }
 
+std::string normalize_url( const std::string& target, const std::string& current_url )
+{
+  if ( target.starts_with( "/" ) ) {
+    if ( target.starts_with( "//" ) ) {
+      return "https:" + target;
+    }
+    const std::size_t slash_pos = current_url.find( '/', 8 );
+    const std::string domain
+      = ( slash_pos == std::string::npos ) ? current_url : current_url.substr( 0, slash_pos );
+    return domain + target;
+  }
+  if ( !target.starts_with( "http" ) ) {
+    const std::size_t last_slash = current_url.rfind( '/' );
+    if ( last_slash > 7 ) {
+      return current_url.substr( 0, last_slash + 1 ) + target;
+    }
+    return current_url + "/" + target;
+  }
+  return target;
+}
+
+std::string strip_ddg_tracker( std::string target )
+{
+  const std::size_t uddg_pos = target.find( "uddg=" );
+  if ( uddg_pos != std::string::npos ) {
+    const std::size_t end_pos = target.find( '&', uddg_pos );
+    const std::string encoded = target.substr( uddg_pos + 5, end_pos - ( uddg_pos + 5 ) );
+    std::string decoded;
+    for ( std::size_t i = 0; i < encoded.length(); ++i ) {
+      if ( encoded[i] == '%' && i + 2 < encoded.length() ) {
+        const std::string hex = encoded.substr( i + 1, 2 );
+        try {
+          decoded += static_cast<char>( std::stoi( hex, nullptr, 16 ) );
+        } catch ( const std::exception& ) {
+          (void)0;
+        }
+        i += 2;
+      } else {
+        decoded += encoded[i];
+      }
+    }
+    return decoded;
+  }
+  return target;
+}
+
 void handle_follow_link( const tui::Terminal& terminal,
                          const std::vector<std::string>& links,
                          std::string& current_url,
@@ -189,23 +308,8 @@ void handle_follow_link( const tui::Terminal& terminal,
       if ( index > 0 && index <= links.size() ) {
         std::string target = links[index - 1];
 
-        if ( target.starts_with( "/" ) ) {
-          if ( target.starts_with( "//" ) ) {
-            target = "https:" + target; // "//example.com"
-          } else {
-            const std::size_t slash_pos = current_url.find( '/', 8 ); // 跳过 https://
-            const std::string domain
-              = ( slash_pos == std::string::npos ) ? current_url : current_url.substr( 0, slash_pos );
-            target = domain + target; // "/about" -> "https://gnu.org/about"
-          }
-        } else if ( !target.starts_with( "http" ) ) {
-          const std::size_t last_slash = current_url.rfind( '/' );
-          if ( last_slash > 7 ) {
-            target = current_url.substr( 0, last_slash + 1 ) + target;
-          } else {
-            target = current_url + "/" + target;
-          }
-        }
+        target = normalize_url( target, current_url );
+        target = strip_ddg_tracker( target );
 
         current_url = target;
         navigate = true;
@@ -276,6 +380,39 @@ InputAction process_key( char c,
   return InputAction::None;
 }
 
+std::vector<std::string> wrap_lines( const std::vector<std::string>& original_lines, std::size_t wrap_width )
+{
+  std::vector<std::string> wrapped_lines;
+  for ( const auto& line : original_lines ) {
+    std::string current_line;
+    std::size_t vis_count = 0;
+    bool in_ansi = false;
+    for ( const char c : line ) {
+      if ( c == '\x1b' ) {
+        in_ansi = true;
+      }
+      if ( in_ansi ) {
+        current_line += c;
+        if ( c == 'm' ) {
+          in_ansi = false;
+        }
+      } else {
+        if ( vis_count >= wrap_width ) {
+          wrapped_lines.push_back( current_line + "\033[0m" );
+          current_line.clear();
+          vis_count = 0;
+        }
+        current_line += c;
+        vis_count++;
+      }
+    }
+    if ( !current_line.empty() || line.empty() ) {
+      wrapped_lines.push_back( current_line + "\033[0m" );
+    }
+  }
+  return wrapped_lines;
+}
+
 } // namespace
 
 int Browser::run( std::string_view initial_url )
@@ -293,11 +430,16 @@ int Browser::run( std::string_view initial_url )
     std::cout.flush();
 
     auto page_data = load_page( current_url );
+
+    auto [term_width, term_height] = terminal.get_size();
+    const std::size_t wrap_width = ( term_width > 1 ) ? ( term_width - 1 ) : 80;
+    page_data.lines = wrap_lines( page_data.lines, wrap_width );
+
     std::size_t scroll_y = 0;
     bool navigate = false;
 
     while ( !navigate ) {
-      draw_view( terminal, page_data.lines, scroll_y, current_url );
+      draw_view( terminal, page_data.lines, scroll_y, current_url, page_data.title );
       const char c = terminal.read_key();
 
       const InputAction action = process_key( c, terminal, page_data, current_url, history, history_idx, scroll_y );
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 5cf6a30..143e067 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -39,7 +39,6 @@ struct ParsedUrl
 std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
 {
   std::string_view prefix = "http://";
-
   if ( url.starts_with( "https://" ) ) {
     prefix = "https://";
   } else if ( url.starts_with( "http://" ) ) {
@@ -49,17 +48,20 @@ std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
   }
 
   url.remove_prefix( prefix.length() );
-  auto slash_pos = url.find( '/' );
+
+  const auto sep_pos = url.find_first_of( "/?#" );
 
   ParsedUrl result;
-  if ( slash_pos == std::string_view::npos ) {
+  if ( sep_pos == std::string_view::npos ) {
     result.host = std::string( url );
     result.path = "/";
   } else {
-    result.host = std::string( url.substr( 0, slash_pos ) );
-    result.path = std::string( url.substr( slash_pos ) );
+    result.host = std::string( url.substr( 0, sep_pos ) );
+    result.path = std::string( url.substr( sep_pos ) );
+    if ( result.path[0] != '/' ) {
+      result.path.insert( 0, "/" );
+    }
   }
-
   return result;
 }
 
diff --git a/ricochet/src/render/renderer.cc b/ricochet/src/render/renderer.cc
index 2b690ca..ed622b4 100644
--- a/ricochet/src/render/renderer.cc
+++ b/ricochet/src/render/renderer.cc
@@ -18,19 +18,21 @@
 
 #include "ricochet/render/renderer.hh"
 #include <array>
+#include <cstdint>
+#include <stdexcept>
 
 namespace ricochet::render {
 
 namespace {
 
-std::string decode_entities( std::string text ) // NOLINT(readability-convert-member-functions-to-static)
+std::string decode_entities( std::string text )
 {
-  constexpr std::array<std::pair<std::string_view, std::string_view>, 24> entities
-    = { { { "&nbsp;", " " },   { "&lt;", "<" },     { "&gt;", ">" },    { "&amp;", "&" },   { "&quot;", "\"" },
-          { "&copy;", "©" },   { "&reg;", "®" },    { "&trade;", "™" }, { "&euro;", "€" },  { "&pound;", "£" },
-          { "&yen;", "¥" },    { "&cent;", "¢" },   { "&sect;", "§" },  { "&para;", "¶" },  { "&hellip;", "…" },
-          { "&dagger;", "†" }, { "&Dagger;", "‡" }, { "&bull;", "•" },  { "&prime;", "′" }, { "&Prime;", "″" },
-          { "&lsaquo;", "‹" }, { "&rsaquo;", "›" }, { "&oline;", "‾" }, { "&frasl;", "⁄" } } };
+  constexpr std::array<std::pair<std::string_view, std::string_view>, 25> entities
+    = { { { "&nbsp;", " " },   { "&lt;", "<" },     { "&gt;", ">" },     { "&amp;", "&" },   { "&quot;", "\"" },
+          { "&apos;", "'" },   { "&copy;", "©" },   { "&reg;", "®" },    { "&trade;", "™" }, { "&euro;", "€" },
+          { "&pound;", "£" },  { "&yen;", "¥" },    { "&cent;", "¢" },   { "&sect;", "§" },  { "&para;", "¶" },
+          { "&hellip;", "…" }, { "&dagger;", "†" }, { "&Dagger;", "‡" }, { "&bull;", "•" },  { "&prime;", "′" },
+          { "&Prime;", "″" },  { "&lsaquo;", "‹" }, { "&rsaquo;", "›" }, { "&oline;", "‾" }, { "&frasl;", "⁄" } } };
 
   for ( const auto& [entity, replacement] : entities ) {
     std::size_t pos = 0;
@@ -39,6 +41,31 @@ std::string decode_entities( std::string text ) // NOLINT(readability-convert-me
       pos += replacement.length();
     }
   }
+
+  std::size_t pos = 0;
+  while ( ( pos = text.find( "&#", pos ) ) != std::string::npos ) {
+    const std::size_t end = text.find( ';', pos );
+    if ( end != std::string::npos && end - pos < 10 ) {
+      const std::string code = text.substr( pos + 2, end - pos - 2 );
+      try {
+        std::uint32_t cp = 0;
+        if ( !code.empty() && ( code[0] == 'x' || code[0] == 'X' ) ) {
+          cp = std::stoul( code.substr( 1 ), nullptr, 16 );
+        } else {
+          cp = std::stoul( code );
+        }
+        if ( cp < 128 ) {
+          text.replace( pos, end - pos + 1, 1, static_cast<char>( cp ) );
+          continue;
+        }
+      } catch ( const std::invalid_argument& ) {
+        (void)0; // Not a valid number, leave as-is
+      } catch ( const std::out_of_range& ) {
+        (void)0; // Value too large, leave as-is
+      }
+    }
+    pos++;
+  }
   return text;
 }
 
@@ -107,7 +134,7 @@ void render_node( const parser::DomNode& node, // NOLINT(misc-no-recursion)
     output += "\033[0m";
     const std::string href = extract_href( node.tag_name );
     if ( !href.empty() && !href.starts_with( "javascript:" ) && !href.starts_with( "#" ) ) {
-      links.push_back( href );
+      links.push_back( decode_entities( href ) );
       output += " \033[7m[" + std::to_string( links.size() ) + "]\033[0m"; // 打印数字标签！
     }
   }
-- 
cgit v1.2.3


From 89267aed9047a5b23e0cb4b364bad90260913577 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Sun, 12 Apr 2026 23:49:02 +0800
Subject: feat: implement HTTP POST support for form submissions and add input
 value persistence

---
 ricochet/include/ricochet/net/http_client.hh |   4 +-
 ricochet/include/ricochet/render/renderer.hh |   3 +
 ricochet/src/core/browser.cc                 | 136 +++++++++++++++++----------
 ricochet/src/net/http_client.cc              |  31 ++++--
 ricochet/src/render/renderer.cc              |  33 +++++--
 5 files changed, 144 insertions(+), 63 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/include/ricochet/net/http_client.hh b/ricochet/include/ricochet/net/http_client.hh
index 2dd7419..45c92e8 100644
--- a/ricochet/include/ricochet/net/http_client.hh
+++ b/ricochet/include/ricochet/net/http_client.hh
@@ -51,7 +51,9 @@ public:
    * @param url Target URL, for example "http://example.com"
    * @return Returns HttpResponse on success, returns an error message string on failure
    */
-  std::expected<HttpResponse, std::string> fetch( std::string_view url ) const;
+  std::expected<HttpResponse, std::string> fetch( std::string_view url,
+                                                  std::string_view method = "GET",
+                                                  std::string_view body = "" ) const;
 
 private:
 };
diff --git a/ricochet/include/ricochet/render/renderer.hh b/ricochet/include/ricochet/render/renderer.hh
index 8c49bbd..dda3ac5 100644
--- a/ricochet/include/ricochet/render/renderer.hh
+++ b/ricochet/include/ricochet/render/renderer.hh
@@ -19,6 +19,7 @@
 #pragma once
 
 #include "ricochet/parser/dom_tree.hh"
+#include <string>
 
 namespace ricochet::render {
 
@@ -27,6 +28,8 @@ struct InputField
   std::string name;
   std::string action;
   std::string method;
+  std::string value {};
+  std::string type {};
 };
 struct RenderResult
 {
diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index 0f6d9d2..e6c63d4 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -37,6 +37,13 @@ struct PageData
   std::string title;
 };
 
+struct HttpRequest
+{
+  std::string url {};
+  std::string method = "GET";
+  std::string body {};
+};
+
 namespace {
 
 std::string extract_title( const parser::DomNode& root_node )
@@ -79,13 +86,12 @@ std::string extract_title( const parser::DomNode& root_node )
   return "";
 }
 
-PageData load_page( std::string_view url )
+PageData load_page( const HttpRequest& req )
 {
   const net::HttpClient client;
-  auto response_result = client.fetch( url );
+  auto response_result = client.fetch( req.url, req.method, req.body );
   if ( !response_result.has_value() ) {
-    return {
-      .lines = { "[!] Failed to load: " + std::string( url ) }, .links = {}, .inputs = {}, .title = "Error" };
+    return { .lines = { "[!] Failed to load: " + req.url }, .links = {}, .inputs = {}, .title = "Error" };
   }
 
   const parser::HtmlLexer lexer;
@@ -150,7 +156,7 @@ void draw_view( const tui::Terminal& terminal,
   }
 
   std::string footer
-    = " URL: " + std::string( url ) + " | [j/k]Scroll [/]Jump [f]Follow [i]Input [H/L]History [q]Quit ";
+    = " URL: " + std::string( url ) + " | [j/k]Scroll [/]Jump [f]Follow [i]Input [r]Refresh [H/L]History [q]Quit ";
   if ( footer.size() < width ) {
     footer.append( width - footer.size(), ' ' );
   } else if ( footer.size() > width && width > 3 ) {
@@ -364,66 +370,96 @@ std::string get_terminal_input( const tui::Terminal& terminal, const std::string
   return input;
 }
 
+InputAction submit_form( const render::InputField& target_input,
+                         const std::vector<render::InputField>& inputs,
+                         const std::string& current_url,
+                         std::vector<HttpRequest>& history,
+                         std::size_t& history_idx )
+{
+  std::string body;
+  for ( const auto& in : inputs ) {
+    if ( in.action == target_input.action && !in.name.empty() && in.type != "submit" && in.type != "button" ) {
+      std::string encoded = in.value;
+      for ( char& ch : encoded ) {
+        if ( ch == ' ' ) {
+          ch = '+';
+        }
+      }
+      if ( !body.empty() ) {
+        body += "&";
+      }
+      body += in.name + "=" + encoded;
+    }
+  }
+  const std::string action
+    = target_input.action.empty() ? current_url : normalize_url( target_input.action, current_url );
+  HttpRequest next_req { .url = action, .method = "GET", .body = "" };
+  if ( target_input.method == "post" || target_input.method == "POST" ) {
+    next_req.method = "POST";
+    next_req.body = body;
+  } else {
+    const char sep = action.contains( '?' ) ? '&' : '?';
+    next_req.url += sep + body;
+  }
+  history.resize( history_idx + 1 );
+  history.push_back( next_req );
+  history_idx++;
+  return InputAction::Navigate;
+}
+
+void update_input_value( PageData& page_data, std::size_t index, const std::string& query )
+{
+  page_data.inputs[index - 1].value = query;
+  const std::string marker = "[I" + std::to_string( index ) + ":";
+  for ( auto& line : page_data.lines ) {
+    const std::size_t pos = line.find( marker );
+    if ( pos != std::string::npos ) {
+      const std::size_t end = line.find( "]", pos );
+      if ( end != std::string::npos ) {
+        line.replace( pos, end - pos + 1, "[I" + std::to_string( index ) + ":" + query + "]" );
+      }
+    }
+  }
+}
+
 InputAction handle_form_input( const tui::Terminal& terminal,
-                               const PageData& page_data,
-                               std::string& current_url,
-                               std::vector<std::string>& history,
+                               PageData& page_data,
+                               const std::string& current_url,
+                               std::vector<HttpRequest>& history,
                                std::size_t& history_idx )
 {
   const std::string num_input = get_terminal_input( terminal, "Select Input [#]:" );
   if ( num_input.empty() ) {
     return InputAction::None;
   }
-
   std::size_t index = 0;
   try {
     index = std::stoul( num_input );
   } catch ( ... ) {
-    (void)0;
-  }
-  if ( index == 0 || index > page_data.inputs.size() ) {
     return InputAction::None;
   }
-
-  const std::string query = get_terminal_input( terminal, "Enter Text [I" + std::to_string( index ) + "]:" );
-  if ( query.empty() ) {
+  if ( index == 0 || index > page_data.inputs.size() ) {
     return InputAction::None;
   }
 
   const auto& target_input = page_data.inputs[index - 1];
-  std::string encoded_query = query;
-  for ( char& ch : encoded_query ) {
-    if ( ch == ' ' ) {
-      ch = '+';
-    }
-  }
-
-  std::string action = target_input.action;
-  if ( action.empty() ) {
-    action = current_url;
-  } else {
-    action = normalize_url( action, current_url );
+  if ( target_input.type == "submit" || target_input.type == "button" ) {
+    return submit_form( target_input, page_data.inputs, current_url, history, history_idx );
   }
 
-  std::string param_name = target_input.name;
-  if ( param_name.empty() ) {
-    param_name = "q";
+  const std::string query = get_terminal_input( terminal, "Enter Text [I" + std::to_string( index ) + "]:" );
+  if ( query.empty() ) {
+    return InputAction::None;
   }
-
-  const char sep = action.contains( '?' ) ? '&' : '?';
-  const std::string target_url = action + sep + param_name + "=" + encoded_query;
-
-  history.resize( history_idx + 1 );
-  history.push_back( target_url );
-  history_idx++;
-  return InputAction::Navigate;
+  update_input_value( page_data, index, query );
+  return InputAction::None;
 }
 
 InputAction process_key( char c,
                          const tui::Terminal& terminal,
-                         const PageData& page_data,
-                         std::string& current_url,
-                         std::vector<std::string>& history,
+                         PageData& page_data,
+                         std::string current_url,
+                         std::vector<HttpRequest>& history,
                          std::size_t& history_idx, // NOLINT(bugprone-easily-swappable-parameters)
                          std::size_t& scroll_y )   // NOLINT(bugprone-easily-swappable-parameters)
 {
@@ -447,12 +483,15 @@ InputAction process_key( char c,
     history_idx++;
     return InputAction::Navigate;
   }
+  if ( c == 'r' ) {
+    return InputAction::Navigate;
+  }
 
   if ( c == '/' ) {
     const std::string next_url = get_url_input( terminal );
     if ( !next_url.empty() ) {
       history.resize( history_idx + 1 );
-      history.push_back( next_url );
+      history.push_back( HttpRequest { .url = next_url, .method = "GET", .body = "" } );
       history_idx++;
       return InputAction::Navigate;
     }
@@ -464,7 +503,7 @@ InputAction process_key( char c,
     handle_follow_link( terminal, page_data.links, current_url, nav );
     if ( nav && current_url != old_url ) {
       history.resize( history_idx + 1 );
-      history.push_back( current_url );
+      history.push_back( HttpRequest { .url = current_url, .method = "GET", .body = "" } );
       history_idx++;
       return InputAction::Navigate;
     }
@@ -513,19 +552,20 @@ std::vector<std::string> wrap_lines( const std::vector<std::string>& original_li
 
 int Browser::run( std::string_view initial_url )
 {
-  std::vector<std::string> history;
-  history.emplace_back( initial_url );
+  std::vector<HttpRequest> history;
+  history.emplace_back( HttpRequest { .url = std::string( initial_url ), .method = "GET", .body = "" } );
   std::size_t history_idx = 0;
   const tui::Terminal terminal;
   terminal.show_cursor( false );
 
   while ( true ) {
-    std::string current_url = history[history_idx];
+    const HttpRequest current_req = history[history_idx];
+    const std::string current_url = current_req.url;
     terminal.clear_screen();
-    std::cout << "-> Fetching: " << current_url << "...\r\n";
+    std::cout << "-> Fetching: " << current_req.url << "...\r\n";
     std::cout.flush();
 
-    auto page_data = load_page( current_url );
+    auto page_data = load_page( current_req );
 
     auto [term_width, term_height] = terminal.get_size();
     const std::size_t wrap_width = ( term_width > 1 ) ? ( term_width - 1 ) : 80;
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 143e067..0d75a7f 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -25,6 +25,7 @@
 #include <cstddef>
 #include <format>
 #include <string>
+#include <string_view>
 
 namespace ricochet::net {
 
@@ -169,22 +170,31 @@ struct FetchResult
 FetchResult do_network_request( const std::string& host,
                                 const std::string& service, // NOLINT(bugprone-easily-swappable-parameters)
                                 const std::string& path,    // NOLINT(bugprone-easily-swappable-parameters)
-                                bool is_https )
+                                bool is_https,
+                                const std::string& method, // NOLINT(bugprone-easily-swappable-parameters)
+                                const std::string& body )  // NOLINT(bugprone-easily-swappable-parameters)
 {
   FetchResult res;
   try {
     const Address server_addr( host, service );
-    const std::string request
-      = std::format( "GET {} HTTP/1.1\r\n"
+    std::string request
+      = std::format( "{} {} HTTP/1.1\r\n"
                      "Host: {}\r\n"
                      "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
                      "Chrome/124.0.0.0 Safari/537.36\r\n"
                      "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
                      "Accept-Language: en-US,en;q=0.9\r\n"
                      "DNT: 1\r\n"
-                     "Connection: close\r\n\r\n",
+                     "Connection: close\r\n",
+                     method,
                      path,
                      host );
+    if ( !body.empty() ) {
+      request += std::format( "Content-Length: {}\r\n"
+                              "Content-Type: application/x-www-form-urlencoded\r\n",
+                              body.length() );
+    }
+    request += "\r\n" + body;
 
     if ( is_https ) {
       SSLSocket ssl_socket;
@@ -217,10 +227,13 @@ FetchResult do_network_request( const std::string& host,
 
 } // namespace
 
-std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url ) const
+std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url, // NOLINT
+                                                            std::string_view method,
+                                                            std::string_view body ) const
 {
-  (void)this; // 完美绕过 static 方法警告，满足最严苛的 tidy 规则
   std::string current_url( url );
+  std::string current_method( method );
+  std::string current_body( body );
 
   for ( int redirect_count = 0; redirect_count < 5; ++redirect_count ) {
     const auto parsed_url = parse_url( current_url );
@@ -232,7 +245,7 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     const bool is_https = current_url.starts_with( "https://" );
     const std::string service = is_https ? "https" : "http";
 
-    const FetchResult net_res = do_network_request( host, service, path, is_https );
+    const FetchResult net_res = do_network_request( host, service, path, is_https, current_method, current_body );
     if ( !net_res.error.empty() ) {
       return std::unexpected( net_res.error );
     }
@@ -258,6 +271,10 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
       const std::string next_url = extract_redirect_url( raw_response, is_https, host );
       if ( !next_url.empty() ) {
         current_url = next_url;
+        if ( response.status_code == 301 || response.status_code == 302 || response.status_code == 303 ) {
+          current_method = "GET";
+          current_body.clear();
+        }
         continue;
       }
     }
diff --git a/ricochet/src/render/renderer.cc b/ricochet/src/render/renderer.cc
index 8708206..4b152b7 100644
--- a/ricochet/src/render/renderer.cc
+++ b/ricochet/src/render/renderer.cc
@@ -154,6 +154,30 @@ bool is_heading_tag( std::string_view tag )
   return tag == "h1" || tag == "h2" || tag == "h3" || tag == "h4";
 }
 
+void render_input_node( const parser::DomNode& node,
+                        RenderResult& result,
+                        const FormContext& ctx,
+                        std::string& output )
+{
+  std::string type = extract_attr( node.tag_name, "type" );
+  const std::size_t space_pos = node.tag_name.find( ' ' );
+  const std::string base_tag
+    = ( space_pos == std::string::npos ) ? node.tag_name : node.tag_name.substr( 0, space_pos );
+  if ( base_tag == "button" && type.empty() ) {
+    type = "submit";
+  }
+  const std::string default_val = extract_attr( node.tag_name, "value" );
+  result.inputs.push_back( { extract_attr( node.tag_name, "name" ), ctx.action, ctx.method, default_val, type } );
+
+  std::string hint = build_input_hint( node.tag_name );
+  if ( base_tag == "button" ) {
+    hint = "Submit";
+  }
+  if ( hint != "hidden" ) {
+    output += " \033[7;33m[I" + std::to_string( result.inputs.size() ) + ":" + hint + "]\033[0m ";
+  }
+}
+
 void render_node( const parser::DomNode& node, // NOLINT(misc-no-recursion)
                   RenderResult& result,
                   FormContext ctx )
@@ -179,7 +203,7 @@ void render_node( const parser::DomNode& node, // NOLINT(misc-no-recursion)
   const bool is_header = is_heading_tag( base_tag );
   const bool is_link = ( base_tag == "a" );
   const bool is_list_item = ( base_tag == "li" );
-  const bool is_input = ( base_tag == "input" || base_tag == "textarea" );
+  const bool is_input = ( base_tag == "input" || base_tag == "textarea" || base_tag == "button" );
 
   if ( is_header ) {
     output += "\n\n\033[1;31m";
@@ -188,12 +212,7 @@ void render_node( const parser::DomNode& node, // NOLINT(misc-no-recursion)
   } else if ( is_list_item ) {
     output += "\n  • ";
   } else if ( is_input ) {
-    result.inputs.push_back( { extract_attr( node.tag_name, "name" ), ctx.action, ctx.method } );
-    const std::string hint = build_input_hint( node.tag_name );
-
-    if ( hint != "hidden" ) {
-      output += " \033[7;33m[I" + std::to_string( result.inputs.size() ) + ":" + hint + "]\033[0m ";
-    }
+    render_input_node( node, result, ctx, output );
   } else if ( base_tag == "p" || base_tag == "div" || is_header ) {
     if ( !output.empty() && output.back() != '\n' ) {
       output += "\n";
-- 
cgit v1.2.3


From 6a9732bced99eb8a33f23c4365a770cde1be5952 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Mon, 13 Apr 2026 00:21:41 +0800
Subject: feat: implement cookie jar management and automatic header injection
 for HTTP requests

---
 ricochet/src/net/http_client.cc | 65 +++++++++++++++++++++++++++++++++++++++--
 1 file changed, 62 insertions(+), 3 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 0d75a7f..240b234 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -26,6 +26,7 @@
 #include <format>
 #include <string>
 #include <string_view>
+#include <unordered_map>
 
 namespace ricochet::net {
 
@@ -162,6 +163,57 @@ std::string extract_redirect_url( const std::string& raw_response, bool is_https
   return "";
 }
 
+std::unordered_map<std::string, std::string>& get_cookie_jar()
+{
+  static std::unordered_map<std::string, std::string> jar;
+  return jar;
+}
+
+void update_cookies( const std::string& raw_response )
+{
+  std::size_t pos = 0;
+  while ( ( pos = raw_response.find( "Set-Cookie: ", pos ) ) != std::string::npos ) {
+    pos += 12;
+    const std::size_t end_pos = raw_response.find( '\r', pos );
+    if ( end_pos == std::string::npos ) {
+      break;
+    }
+
+    const std::string cookie_line = raw_response.substr( pos, end_pos - pos );
+    const std::size_t semi_pos = cookie_line.find( ';' );
+    const std::string cookie_pair
+      = ( semi_pos == std::string::npos ) ? cookie_line : cookie_line.substr( 0, semi_pos );
+
+    const std::size_t eq_pos = cookie_pair.find( '=' );
+    if ( eq_pos != std::string::npos ) {
+      const std::string key = cookie_pair.substr( 0, eq_pos );
+      const std::string val = cookie_pair.substr( eq_pos + 1 );
+      get_cookie_jar()[key] = val;
+    }
+  }
+}
+
+std::string build_cookie_header()
+{
+  const auto& jar = get_cookie_jar();
+  if ( jar.empty() ) {
+    return "";
+  }
+  std::string header = "Cookie: ";
+  bool first = true;
+  for ( const auto& [k, v] : jar ) {
+    if ( !first ) {
+      header += "; ";
+    }
+    header += k;
+    header += "=";
+    header += v;
+    first = false;
+  }
+  header += "\r\n";
+  return header;
+}
+
 struct FetchResult
 {
   std::string raw_response {};
@@ -172,7 +224,8 @@ FetchResult do_network_request( const std::string& host,
                                 const std::string& path,    // NOLINT(bugprone-easily-swappable-parameters)
                                 bool is_https,
                                 const std::string& method, // NOLINT(bugprone-easily-swappable-parameters)
-                                const std::string& body )  // NOLINT(bugprone-easily-swappable-parameters)
+                                const std::string& body,
+                                const std::string& cookie_header ) // NOLINT(bugprone-easily-swappable-parameters)
 {
   FetchResult res;
   try {
@@ -185,10 +238,12 @@ FetchResult do_network_request( const std::string& host,
                      "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
                      "Accept-Language: en-US,en;q=0.9\r\n"
                      "DNT: 1\r\n"
+                     "{}"
                      "Connection: close\r\n",
                      method,
                      path,
-                     host );
+                     host,
+                     cookie_header );
     if ( !body.empty() ) {
       request += std::format( "Content-Length: {}\r\n"
                               "Content-Type: application/x-www-form-urlencoded\r\n",
@@ -245,11 +300,15 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     const bool is_https = current_url.starts_with( "https://" );
     const std::string service = is_https ? "https" : "http";
 
-    const FetchResult net_res = do_network_request( host, service, path, is_https, current_method, current_body );
+    const std::string cookie_header = build_cookie_header();
+
+    const FetchResult net_res
+      = do_network_request( host, service, path, is_https, current_method, current_body, cookie_header );
     if ( !net_res.error.empty() ) {
       return std::unexpected( net_res.error );
     }
     const std::string& raw_response = net_res.raw_response;
+    update_cookies( raw_response );
 
     HttpResponse response;
     const auto header_end = raw_response.find( "\r\n\r\n" );
-- 
cgit v1.2.3


From 331fde79776286de58247f565839b1eae154f7c4 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Mon, 13 Apr 2026 02:11:27 +0800
Subject: feat: add binary file download support by parsing Content-Type
 headers

---
 ricochet/include/ricochet/net/http_client.hh |  1 +
 ricochet/src/core/browser.cc                 | 78 +++++++++++++++++++++++-----
 ricochet/src/net/http_client.cc              | 12 +++++
 3 files changed, 78 insertions(+), 13 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/include/ricochet/net/http_client.hh b/ricochet/include/ricochet/net/http_client.hh
index 45c92e8..f6d8aa3 100644
--- a/ricochet/include/ricochet/net/http_client.hh
+++ b/ricochet/include/ricochet/net/http_client.hh
@@ -33,6 +33,7 @@ struct HttpResponse
   int status_code { 0 };
   std::unordered_map<std::string, std::string> headers {};
   std::string body {};
+  std::string content_type {};
 };
 
 class HttpClient
diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index 1457929..57ed496 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -135,6 +135,53 @@ std::string generate_bookmarks_html()
   return html;
 }
 
+PageData process_binary_download( const HttpRequest& req, const net::HttpResponse& resp )
+{
+  std::string fname = "download.dat";
+  const std::size_t slash = req.url.rfind( '/' );
+  if ( slash != std::string::npos && slash + 1 < req.url.length() ) {
+    fname = req.url.substr( slash + 1 );
+    const std::size_t q_pos = fname.find( '?' );
+    if ( q_pos != std::string::npos ) {
+      fname = fname.substr( 0, q_pos );
+    }
+  }
+  if ( fname.empty() ) {
+    fname = "download.dat";
+  }
+
+  std::ofstream out( fname, std::ios::binary );
+  out.write( resp.body.data(), static_cast<std::streamsize>( resp.body.size() ) );
+  out.close();
+
+  return { .lines = { "\033[1;32m[ Download Complete ]\033[0m",
+                      "",
+                      "Saved File : " + fname,
+                      "File Type  : " + resp.content_type,
+                      "File Size  : " + std::to_string( resp.body.size() ) + " bytes",
+                      "",
+                      "Press 'H' to return to the previous page." },
+           .links = {},
+           .inputs = {},
+           .title = "Download Manager" };
+}
+
+std::vector<std::string> split_into_lines( const std::string& text )
+{
+  std::vector<std::string> lines;
+  std::size_t start = 0;
+  while ( start < text.length() ) {
+    const std::size_t end = text.find( '\n', start );
+    if ( end == std::string::npos ) {
+      lines.push_back( text.substr( start ) );
+      break;
+    }
+    lines.push_back( text.substr( start, end - start ) );
+    start = end + 1;
+  }
+  return lines;
+}
+
 PageData load_page( const HttpRequest& req )
 {
   std::string html_body;
@@ -146,6 +193,21 @@ PageData load_page( const HttpRequest& req )
     if ( !response_result.has_value() ) {
       return { .lines = { "[!] Failed to load: " + req.url }, .links = {}, .inputs = {}, .title = "Error" };
     }
+
+    const auto& resp = response_result.value();
+    std::string c_type = resp.content_type;
+    for ( char& c : c_type ) {
+      if ( c >= 'A' && c <= 'Z' ) {
+        c = static_cast<char>( c + 32 );
+      }
+    }
+
+    const bool is_text
+      = c_type.starts_with( "text/" ) || c_type.contains( "xml" ) || c_type.contains( "json" ) || c_type.empty();
+
+    if ( !is_text ) {
+      return process_binary_download( req, resp );
+    }
     html_body = response_result.value().body;
   }
 
@@ -155,20 +217,10 @@ PageData load_page( const HttpRequest& req )
 
   const auto dom_root = builder.build( lexer.tokenize( html_body ) );
   const render::RenderResult result = renderer.render( dom_root );
-
-  std::vector<std::string> lines;
-  std::size_t start = 0;
-  while ( start < result.text.length() ) {
-    const std::size_t end = result.text.find( '\n', start );
-    if ( end == std::string::npos ) {
-      lines.push_back( result.text.substr( start ) );
-      break;
-    }
-    lines.push_back( result.text.substr( start, end - start ) );
-    start = end + 1;
-  }
   const std::string title = extract_title( dom_root );
-  return { .lines = lines, .links = result.links, .inputs = result.inputs, .title = title };
+
+  return {
+    .lines = split_into_lines( result.text ), .links = result.links, .inputs = result.inputs, .title = title };
 }
 
 void draw_view( const tui::Terminal& terminal,
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 240b234..7372247 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -314,6 +314,18 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     const auto header_end = raw_response.find( "\r\n\r\n" );
     if ( header_end != std::string::npos ) {
       response.body = raw_response.substr( header_end + 4 );
+      const std::string headers = raw_response.substr( 0, header_end );
+      std::size_t ct_pos = headers.find( "Content-Type: " );
+      if ( ct_pos == std::string::npos ) {
+        ct_pos = headers.find( "content-type: " );
+      }
+      if ( ct_pos != std::string::npos ) {
+        ct_pos += 14;
+        const std::size_t end_pos = headers.find( '\r', ct_pos );
+        if ( end_pos != std::string::npos ) {
+          response.content_type = headers.substr( ct_pos, end_pos - ct_pos );
+        }
+      }
       if ( raw_response.size() >= 12 ) {
         try {
           response.status_code = std::stoi( raw_response.substr( 9, 3 ) );
-- 
cgit v1.2.3


From a10bbaf20ac20278701b182a5a45a5edf73e9d0a Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Mon, 13 Apr 2026 02:33:09 +0800
Subject: feat: improve error reporting, implement responsive footer layout,
 and refine HTTP response processing for non-text content types

---
 ricochet/src/core/browser.cc    | 49 ++++++++++++++++++++++++++++++++++-------
 ricochet/src/net/http_client.cc | 23 ++++++++++++++-----
 2 files changed, 58 insertions(+), 14 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index 57ed496..e9f1fce 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -191,7 +191,11 @@ PageData load_page( const HttpRequest& req )
     const net::HttpClient client;
     auto response_result = client.fetch( req.url, req.method, req.body );
     if ( !response_result.has_value() ) {
-      return { .lines = { "[!] Failed to load: " + req.url }, .links = {}, .inputs = {}, .title = "Error" };
+      return { .lines
+               = { "\033[1;31m[!] Failed to load:\033[0m " + req.url, "", "Reason: " + response_result.error() },
+               .links = {},
+               .inputs = {},
+               .title = "Error" };
     }
 
     const auto& resp = response_result.value();
@@ -223,6 +227,41 @@ PageData load_page( const HttpRequest& req )
     .lines = split_into_lines( result.text ), .links = result.links, .inputs = result.inputs, .title = title };
 }
 
+// --- 🔪 智能底部排版：优先截断 URL，誓死保卫快捷键 ---
+std::string build_footer( std::string_view url, std::size_t width )
+{
+  const std::string_view keys = " | [j/k]Scroll [/]Nav [f]Link [i]In [r]Ref [H/L]Hist [b/B]Mark [q]Quit ";
+  const std::string_view prefix = " URL: ";
+
+  std::string footer;
+  if ( width <= keys.length() + prefix.length() + 3 ) {
+    footer.reserve( prefix.length() + url.length() + keys.length() );
+    footer += prefix;
+    footer += url;
+    footer += keys;
+    if ( footer.length() > width && width > 3 ) {
+      footer.erase( width - 3 );
+      footer += "...";
+    }
+  } else {
+    const std::size_t max_url_len = width - keys.length() - prefix.length();
+    footer.reserve( width );
+    footer += prefix;
+    if ( url.length() > max_url_len ) {
+      footer += url.substr( 0, max_url_len - 3 );
+      footer += "...";
+    } else {
+      footer += url;
+    }
+    footer += keys;
+  }
+
+  if ( footer.length() < width ) {
+    footer.append( width - footer.length(), ' ' );
+  }
+  return footer;
+}
+
 void draw_view( const tui::Terminal& terminal,
                 const std::vector<std::string>& lines,
                 std::size_t scroll_y,
@@ -262,13 +301,7 @@ void draw_view( const tui::Terminal& terminal,
     }
   }
 
-  std::string footer
-    = " URL: " + std::string( url ) + " | [j/k]Scroll [/]Jump [f]Follow [i]Input [b]Mark [B]Marks [q]Quit ";
-  if ( footer.size() < width ) {
-    footer.append( width - footer.size(), ' ' );
-  } else if ( footer.size() > width && width > 3 ) {
-    footer = footer.substr( 0, width - 3 ) + "...";
-  }
+  const std::string footer = build_footer( url, width );
   std::cout << "\033[7m" << footer << "\033[0m";
   std::cout.flush();
 }
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 7372247..bbc5d17 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -308,13 +308,15 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
       return std::unexpected( net_res.error );
     }
     const std::string& raw_response = net_res.raw_response;
-    update_cookies( raw_response );
 
     HttpResponse response;
     const auto header_end = raw_response.find( "\r\n\r\n" );
+    const std::string headers
+      = ( header_end != std::string::npos ) ? raw_response.substr( 0, header_end ) : raw_response;
+    update_cookies( headers );
+
     if ( header_end != std::string::npos ) {
       response.body = raw_response.substr( header_end + 4 );
-      const std::string headers = raw_response.substr( 0, header_end );
       std::size_t ct_pos = headers.find( "Content-Type: " );
       if ( ct_pos == std::string::npos ) {
         ct_pos = headers.find( "content-type: " );
@@ -339,7 +341,7 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     }
 
     if ( response.status_code >= 300 && response.status_code < 400 ) {
-      const std::string next_url = extract_redirect_url( raw_response, is_https, host );
+      const std::string next_url = extract_redirect_url( headers, is_https, host );
       if ( !next_url.empty() ) {
         current_url = next_url;
         if ( response.status_code == 301 || response.status_code == 302 || response.status_code == 303 ) {
@@ -353,9 +355,18 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     if ( raw_response.contains( "Transfer-Encoding: chunked" ) ) {
       response.body = dechunk( response.body );
     }
-    response.body = remove_html_comments( response.body );
-    response.body = remove_tag_blocks( response.body, "script" );
-    response.body = remove_tag_blocks( response.body, "style" );
+    std::string ct_lower = response.content_type;
+    for ( char& c : ct_lower ) {
+      if ( c >= 'A' && c <= 'Z' ) {
+        c = static_cast<char>( c + 32 );
+      }
+    }
+
+    if ( ct_lower.starts_with( "text/" ) || ct_lower.contains( "xml" ) ) {
+      response.body = remove_html_comments( response.body );
+      response.body = remove_tag_blocks( response.body, "script" );
+      response.body = remove_tag_blocks( response.body, "style" );
+    }
     return response;
   }
 
-- 
cgit v1.2.3


From b8d188763c1a92c9ad01a1645c82e5196de4d4ec Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Mon, 13 Apr 2026 02:55:36 +0800
Subject: feat: implement persistent cookie storage and migrate configuration
 files to ~/.ricochet directory

---
 ricochet/src/core/browser.cc    | 14 ++++++++++--
 ricochet/src/net/http_client.cc | 47 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 2 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index e9f1fce..03c34bc 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -23,10 +23,12 @@
 #include "ricochet/render/renderer.hh"
 #include "ricochet/tui/terminal.hh"
 #include <cstddef>
+#include <cstdlib>
 #include <exception>
 #include <fstream>
 #include <iostream>
 #include <ranges>
+#include <sys/stat.h>
 
 namespace ricochet::core {
 
@@ -47,6 +49,14 @@ struct HttpRequest
 
 namespace {
 
+std::string get_config_path( const std::string& filename )
+{
+  const char* home = std::getenv( "HOME" ); // NOLINT(concurrency-mt-unsafe)
+  const std::string dir = ( home != nullptr ) ? std::string( home ) + "/.ricochet" : ".ricochet";
+  static_cast<void>( mkdir( dir.c_str(), 0755 ) );
+  return dir + "/" + filename;
+}
+
 std::string extract_title( const parser::DomNode& root_node )
 {
   std::vector<const parser::DomNode*> stack;
@@ -93,7 +103,7 @@ void save_bookmark( const std::string& title, // NOLINT(bugprone-easily-swappabl
   if ( url == "ricochet://bookmarks" ) {
     return;
   }
-  std::ofstream file( "bookmarks.txt", std::ios::app );
+  std::ofstream file( get_config_path( "bookmarks.txt" ), std::ios::app );
   if ( !file.is_open() ) {
     return;
   }
@@ -112,7 +122,7 @@ void save_bookmark( const std::string& title, // NOLINT(bugprone-easily-swappabl
 
 std::string generate_bookmarks_html()
 {
-  std::ifstream file( "bookmarks.txt" );
+  std::ifstream file( get_config_path( "bookmarks.txt" ) );
   std::string html = "<html><head><title>My Bookmarks</title></head><body><h1>Saved Bookmarks</h1><ul>";
   if ( !file.is_open() ) {
     html += "<li>No bookmarks found. Press 'b' on any page to add one!</li>";
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index bbc5d17..5a56ac3 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -23,9 +23,12 @@
 #include "ricochet/net/sys/socket.hh"
 
 #include <cstddef>
+#include <cstdlib>
 #include <format>
+#include <fstream>
 #include <string>
 #include <string_view>
+#include <sys/stat.h>
 #include <unordered_map>
 
 namespace ricochet::net {
@@ -163,15 +166,55 @@ std::string extract_redirect_url( const std::string& raw_response, bool is_https
   return "";
 }
 
+std::string get_config_path( const std::string& filename )
+{
+  const char* home = std::getenv( "HOME" ); // NOLINT(concurrency-mt-unsafe)
+  const std::string dir = ( home != nullptr ) ? std::string( home ) + "/.ricochet" : ".ricochet";
+  static_cast<void>( mkdir( dir.c_str(), 0755 ) );
+  return dir + "/" + filename;
+}
+
+void load_cookies_from_file( std::unordered_map<std::string, std::string>& jar )
+{
+  std::ifstream file( get_config_path( "cookies.txt" ) );
+  if ( !file.is_open() ) {
+    return;
+  }
+  std::string line;
+  while ( std::getline( file, line ) ) {
+    const std::size_t tab_pos = line.find( '\t' );
+    if ( tab_pos != std::string::npos ) {
+      jar[line.substr( 0, tab_pos )] = line.substr( tab_pos + 1 );
+    }
+  }
+}
+
 std::unordered_map<std::string, std::string>& get_cookie_jar()
 {
   static std::unordered_map<std::string, std::string> jar;
+  static bool initialized = false;
+  if ( !initialized ) {
+    load_cookies_from_file( jar );
+    initialized = true;
+  }
   return jar;
 }
 
+void save_cookies_to_file( const std::unordered_map<std::string, std::string>& jar )
+{
+  std::ofstream file( get_config_path( "cookies.txt" ), std::ios::trunc );
+  if ( !file.is_open() ) {
+    return;
+  }
+  for ( const auto& [k, v] : jar ) {
+    file << k << '\t' << v << '\n';
+  }
+}
+
 void update_cookies( const std::string& raw_response )
 {
   std::size_t pos = 0;
+  bool updated = false;
   while ( ( pos = raw_response.find( "Set-Cookie: ", pos ) ) != std::string::npos ) {
     pos += 12;
     const std::size_t end_pos = raw_response.find( '\r', pos );
@@ -189,8 +232,12 @@ void update_cookies( const std::string& raw_response )
       const std::string key = cookie_pair.substr( 0, eq_pos );
       const std::string val = cookie_pair.substr( eq_pos + 1 );
       get_cookie_jar()[key] = val;
+      updated = true;
     }
   }
+  if ( updated ) {
+    save_cookies_to_file( get_cookie_jar() );
+  }
 }
 
 std::string build_cookie_header()
-- 
cgit v1.2.3


From 1f6db22de48da17caf7fb89ef9a64ea3393b5828 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Mon, 13 Apr 2026 04:00:14 +0800
Subject: refactor: update cookie jar to store cookies by domain instead of
 global keys

---
 ricochet/src/net/http_client.cc | 45 ++++++++++++++++++++++++++---------------
 1 file changed, 29 insertions(+), 16 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 5a56ac3..2ed33e3 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -174,24 +174,31 @@ std::string get_config_path( const std::string& filename )
   return dir + "/" + filename;
 }
 
-void load_cookies_from_file( std::unordered_map<std::string, std::string>& jar )
+using CookieJar = std::unordered_map<std::string, std::unordered_map<std::string, std::string>>;
+
+void load_cookies_from_file( CookieJar& jar )
 {
   std::ifstream file( get_config_path( "cookies.txt" ) );
   if ( !file.is_open() ) {
     return;
   }
+
   std::string line;
   while ( std::getline( file, line ) ) {
-    const std::size_t tab_pos = line.find( '\t' );
-    if ( tab_pos != std::string::npos ) {
-      jar[line.substr( 0, tab_pos )] = line.substr( tab_pos + 1 );
+    const std::size_t t1 = line.find( '\t' );
+    if ( t1 == std::string::npos ) {
+      continue;
+    }
+    const std::size_t t2 = line.find( '\t', t1 + 1 );
+    if ( t2 != std::string::npos ) {
+      jar[line.substr( 0, t1 )][line.substr( t1 + 1, t2 - t1 - 1 )] = line.substr( t2 + 1 );
     }
   }
 }
 
-std::unordered_map<std::string, std::string>& get_cookie_jar()
+CookieJar& get_cookie_jar()
 {
-  static std::unordered_map<std::string, std::string> jar;
+  static CookieJar jar;
   static bool initialized = false;
   if ( !initialized ) {
     load_cookies_from_file( jar );
@@ -200,18 +207,22 @@ std::unordered_map<std::string, std::string>& get_cookie_jar()
   return jar;
 }
 
-void save_cookies_to_file( const std::unordered_map<std::string, std::string>& jar )
+void save_cookies_to_file( const CookieJar& jar )
 {
   std::ofstream file( get_config_path( "cookies.txt" ), std::ios::trunc );
   if ( !file.is_open() ) {
     return;
   }
-  for ( const auto& [k, v] : jar ) {
-    file << k << '\t' << v << '\n';
+
+  for ( const auto& [domain, cookies] : jar ) {
+    for ( const auto& [k, v] : cookies ) {
+      file << domain << '\t' << k << '\t' << v << '\n';
+    }
   }
 }
 
-void update_cookies( const std::string& raw_response )
+void update_cookies( const std::string& raw_response, // NOLINT(bugprone-easily-swappable-parameters)
+                     const std::string& host )
 {
   std::size_t pos = 0;
   bool updated = false;
@@ -231,7 +242,7 @@ void update_cookies( const std::string& raw_response )
     if ( eq_pos != std::string::npos ) {
       const std::string key = cookie_pair.substr( 0, eq_pos );
       const std::string val = cookie_pair.substr( eq_pos + 1 );
-      get_cookie_jar()[key] = val;
+      get_cookie_jar()[host][key] = val;
       updated = true;
     }
   }
@@ -240,15 +251,17 @@ void update_cookies( const std::string& raw_response )
   }
 }
 
-std::string build_cookie_header()
+std::string build_cookie_header( const std::string& host )
 {
   const auto& jar = get_cookie_jar();
-  if ( jar.empty() ) {
+  auto it = jar.find( host );
+  if ( it == jar.end() || it->second.empty() ) {
     return "";
   }
+
   std::string header = "Cookie: ";
   bool first = true;
-  for ( const auto& [k, v] : jar ) {
+  for ( const auto& [k, v] : it->second ) {
     if ( !first ) {
       header += "; ";
     }
@@ -347,7 +360,7 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     const bool is_https = current_url.starts_with( "https://" );
     const std::string service = is_https ? "https" : "http";
 
-    const std::string cookie_header = build_cookie_header();
+    const std::string cookie_header = build_cookie_header( host );
 
     const FetchResult net_res
       = do_network_request( host, service, path, is_https, current_method, current_body, cookie_header );
@@ -360,7 +373,7 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     const auto header_end = raw_response.find( "\r\n\r\n" );
     const std::string headers
       = ( header_end != std::string::npos ) ? raw_response.substr( 0, header_end ) : raw_response;
-    update_cookies( headers );
+    update_cookies( headers, host );
 
     if ( header_end != std::string::npos ) {
       response.body = raw_response.substr( header_end + 4 );
-- 
cgit v1.2.3


From 2141017d7c688a0f6659c3ffe5730f281f7551ae Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Mon, 13 Apr 2026 04:34:50 +0800
Subject: feat: implement configurable homepage and user-agent via config.txt

---
 ricochet/include/ricochet/core/browser.hh |  1 +
 ricochet/src/core/browser.cc              | 15 ++++++++
 ricochet/src/main.cc                      | 28 +++++++-------
 ricochet/src/net/http_client.cc           | 61 ++++++++++++++++++++++++-------
 4 files changed, 77 insertions(+), 28 deletions(-)

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/include/ricochet/core/browser.hh b/ricochet/include/ricochet/core/browser.hh
index a8d2cd3..36e876d 100644
--- a/ricochet/include/ricochet/core/browser.hh
+++ b/ricochet/include/ricochet/core/browser.hh
@@ -33,6 +33,7 @@ public:
   Browser( Browser&& ) = delete;
   Browser& operator=( Browser&& ) = delete;
 
+  static std::string get_configured_homepage();
   static int run( std::string_view initial_url );
 };
 
diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index dd96c7c..571783a 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -1003,6 +1003,21 @@ std::vector<std::string> wrap_lines( const std::vector<std::string>& original_li
 
 } // namespace
 
+std::string Browser::get_configured_homepage()
+{
+  std::ifstream file( get_config_path( "config.txt" ) );
+  if ( file.is_open() ) {
+    std::string line;
+    while ( std::getline( file, line ) ) {
+      const std::size_t eq = line.find( '=' );
+      if ( eq != std::string::npos && line.substr( 0, eq ) == "homepage" ) {
+        return line.substr( eq + 1 );
+      }
+    }
+  }
+  return "https://wikipedia.org";
+}
+
 int Browser::run( std::string_view initial_url )
 {
   std::vector<HttpRequest> history;
diff --git a/ricochet/src/main.cc b/ricochet/src/main.cc
index 1037833..562861a 100644
--- a/ricochet/src/main.cc
+++ b/ricochet/src/main.cc
@@ -16,6 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include <fstream>
 #include <iostream>
 #include <span>
 #include <string_view>
@@ -41,28 +42,27 @@ int main( int argc, char* argv[] )
 
   ricochet::core::print_license_notice();
 
+  std::string start_url;
   if ( args.size() < 2 ) {
-    std::cerr << "Error: No URL provided.\n";
-    print_usage( args[0] );
-    return 1;
+    start_url = ricochet::core::Browser::get_configured_homepage();
+  } else {
+    start_url = std::string( args[1] );
   }
 
-  const std::string_view input = args[1];
-
-  if ( input == "show" ) {
-    if ( args[2] == "w" ) {
+  if ( args.size() >= 2 && args[1] == "show" ) {
+    if ( args.size() >= 3 && args[2] == "w" ) {
       ricochet::core::show_warranty();
-    } else if ( args[2] == "c" ) {
+      return 0;
+    }
+    if ( args.size() >= 3 && args[2] == "c" ) {
       ricochet::core::show_copying();
-    } else {
-      std::cerr << "Error: Invalid argument for show command.\n";
-      print_usage( args[0] );
-      return 1;
+      return 0;
     }
-    return 0;
+    std::cerr << "Error: Invalid argument for show command.\n";
+    print_usage( args[0] );
+    return 1;
   }
 
-  std::string start_url( input );
   if ( !start_url.starts_with( "http://" ) && !start_url.starts_with( "https://" ) ) {
     start_url.insert( 0, "https://" );
   }
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 2ed33e3..5f5b449 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -174,6 +174,40 @@ std::string get_config_path( const std::string& filename )
   return dir + "/" + filename;
 }
 
+struct BrowserConfig
+{
+  std::string user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
+                           "Chrome/124.0.0.0 Safari/537.36";
+  std::string homepage = "https://wikipedia.org";
+};
+
+BrowserConfig& get_browser_config()
+{
+  static BrowserConfig config;
+  static bool loaded = false;
+  if ( !loaded ) {
+    std::ifstream file( get_config_path( "config.txt" ) );
+    if ( file.is_open() ) {
+      std::string line;
+      while ( std::getline( file, line ) ) {
+        const std::size_t eq = line.find( '=' );
+        if ( eq == std::string::npos ) {
+          continue;
+        }
+        const std::string key = line.substr( 0, eq );
+        const std::string val = line.substr( eq + 1 );
+        if ( key == "user_agent" ) {
+          config.user_agent = val;
+        } else if ( key == "homepage" ) {
+          config.homepage = val;
+        }
+      }
+    }
+    loaded = true;
+  }
+  return config;
+}
+
 using CookieJar = std::unordered_map<std::string, std::unordered_map<std::string, std::string>>;
 
 void load_cookies_from_file( CookieJar& jar )
@@ -290,20 +324,19 @@ FetchResult do_network_request( const std::string& host,
   FetchResult res;
   try {
     const Address server_addr( host, service );
-    std::string request
-      = std::format( "{} {} HTTP/1.1\r\n"
-                     "Host: {}\r\n"
-                     "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
-                     "Chrome/124.0.0.0 Safari/537.36\r\n"
-                     "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
-                     "Accept-Language: en-US,en;q=0.9\r\n"
-                     "DNT: 1\r\n"
-                     "{}"
-                     "Connection: close\r\n",
-                     method,
-                     path,
-                     host,
-                     cookie_header );
+    std::string request = std::format( "{} {} HTTP/1.1\r\n"
+                                       "Host: {}\r\n"
+                                       "User-Agent: {}\r\n"
+                                       "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
+                                       "Accept-Language: en-US,en;q=0.9\r\n"
+                                       "DNT: 1\r\n"
+                                       "{}"
+                                       "Connection: close\r\n",
+                                       method,
+                                       path,
+                                       host,
+                                       get_browser_config().user_agent,
+                                       cookie_header );
     if ( !body.empty() ) {
       request += std::format( "Content-Length: {}\r\n"
                               "Content-Type: application/x-www-form-urlencoded\r\n",
-- 
cgit v1.2.3


From 77e910cc68f08eb547c45318a050a23191f65209 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Tue, 14 Apr 2026 14:38:42 +0800
Subject: refactor: adjust code structure

---
 ricochet/include/ricochet/core/form_handler.hh     |  38 +
 ricochet/include/ricochet/core/link_hints.hh       |  27 +
 ricochet/include/ricochet/core/local_data.hh       |  32 +
 ricochet/include/ricochet/core/page_loader.hh      |  32 +
 ricochet/include/ricochet/core/page_processor.hh   |  32 +
 ricochet/include/ricochet/core/search_handler.hh   |  23 +
 ricochet/include/ricochet/core/types.hh            |  54 ++
 ricochet/include/ricochet/core/ui_input.hh         |  29 +
 ricochet/include/ricochet/core/ui_view.hh          |  37 +
 ricochet/include/ricochet/core/utils.hh            |  32 +
 ricochet/include/ricochet/net/config.hh            |  35 +
 ricochet/include/ricochet/net/cookie_jar.hh        |  35 +
 ricochet/include/ricochet/net/http_client.hh       |   3 +-
 ricochet/include/ricochet/net/http_utils.hh        |  30 +
 ricochet/include/ricochet/net/url_parser.hh        |  37 +
 ricochet/include/ricochet/render/input_renderer.hh |  34 +
 ricochet/include/ricochet/render/internal.hh       |  35 +
 ricochet/include/ricochet/render/table_renderer.hh |  30 +
 ricochet/include/ricochet/render/utils.hh          |  33 +
 ricochet/src/core/browser.cc                       | 870 +--------------------
 ricochet/src/core/form_handler.cc                  | 165 ++++
 ricochet/src/core/link_hints.cc                    | 104 +++
 ricochet/src/core/local_data.cc                    | 171 ++++
 ricochet/src/core/page_loader.cc                   |  78 ++
 ricochet/src/core/page_processor.cc                |  97 +++
 ricochet/src/core/search_handler.cc                |  81 ++
 ricochet/src/core/ui_input.cc                      |  94 +++
 ricochet/src/core/ui_view.cc                       | 103 +++
 ricochet/src/core/utils.cc                         | 118 +++
 ricochet/src/net/config.cc                         |  64 ++
 ricochet/src/net/cookie_jar.cc                     | 124 +++
 ricochet/src/net/http_client.cc                    | 393 ++--------
 ricochet/src/net/http_utils.cc                     |  93 +++
 ricochet/src/net/url_parser.cc                     |  87 +++
 ricochet/src/render/input_renderer.cc              |  82 ++
 ricochet/src/render/renderer.cc                    | 303 +------
 ricochet/src/render/table_renderer.cc              | 147 ++++
 ricochet/src/render/utils.cc                       | 135 ++++
 38 files changed, 2434 insertions(+), 1483 deletions(-)
 create mode 100644 ricochet/include/ricochet/core/form_handler.hh
 create mode 100644 ricochet/include/ricochet/core/link_hints.hh
 create mode 100644 ricochet/include/ricochet/core/local_data.hh
 create mode 100644 ricochet/include/ricochet/core/page_loader.hh
 create mode 100644 ricochet/include/ricochet/core/page_processor.hh
 create mode 100644 ricochet/include/ricochet/core/search_handler.hh
 create mode 100644 ricochet/include/ricochet/core/types.hh
 create mode 100644 ricochet/include/ricochet/core/ui_input.hh
 create mode 100644 ricochet/include/ricochet/core/ui_view.hh
 create mode 100644 ricochet/include/ricochet/core/utils.hh
 create mode 100644 ricochet/include/ricochet/net/config.hh
 create mode 100644 ricochet/include/ricochet/net/cookie_jar.hh
 create mode 100644 ricochet/include/ricochet/net/http_utils.hh
 create mode 100644 ricochet/include/ricochet/net/url_parser.hh
 create mode 100644 ricochet/include/ricochet/render/input_renderer.hh
 create mode 100644 ricochet/include/ricochet/render/internal.hh
 create mode 100644 ricochet/include/ricochet/render/table_renderer.hh
 create mode 100644 ricochet/include/ricochet/render/utils.hh
 create mode 100644 ricochet/src/core/form_handler.cc
 create mode 100644 ricochet/src/core/link_hints.cc
 create mode 100644 ricochet/src/core/local_data.cc
 create mode 100644 ricochet/src/core/page_loader.cc
 create mode 100644 ricochet/src/core/page_processor.cc
 create mode 100644 ricochet/src/core/search_handler.cc
 create mode 100644 ricochet/src/core/ui_input.cc
 create mode 100644 ricochet/src/core/ui_view.cc
 create mode 100644 ricochet/src/core/utils.cc
 create mode 100644 ricochet/src/net/config.cc
 create mode 100644 ricochet/src/net/cookie_jar.cc
 create mode 100644 ricochet/src/net/http_utils.cc
 create mode 100644 ricochet/src/net/url_parser.cc
 create mode 100644 ricochet/src/render/input_renderer.cc
 create mode 100644 ricochet/src/render/table_renderer.cc
 create mode 100644 ricochet/src/render/utils.cc

(limited to 'ricochet/src/net/http_client.cc')

diff --git a/ricochet/include/ricochet/core/form_handler.hh b/ricochet/include/ricochet/core/form_handler.hh
new file mode 100644
index 0000000..5abf148
--- /dev/null
+++ b/ricochet/include/ricochet/core/form_handler.hh
@@ -0,0 +1,38 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+
+#pragma once
+
+#include "ricochet/core/types.hh"
+#include "ricochet/render/renderer.hh"
+#include "ricochet/tui/terminal.hh"
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace ricochet::core {
+
+InputAction submit_form( const render::InputField& target_input,
+                         const std::vector<render::InputField>& inputs,
+                         const std::string& current_url,
+                         std::vector<HttpRequest>& history,
+                         std::size_t& history_idx );
+
+void update_input_value( PageData& page_data, std::size_t index, const std::string& query );
+void update_single_line_ui( std::string& line, const std::string& marker, const render::InputField& in );
+void update_toggle_ui( PageData& page_data );
+
+InputAction handle_form_input( const tui::Terminal& terminal,
+                               PageData& page_data,
+                               const std::string& current_url,
+                               std::vector<HttpRequest>& history,
+                               std::size_t& history_idx );
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/link_hints.hh b/ricochet/include/ricochet/core/link_hints.hh
new file mode 100644
index 0000000..5da4846
--- /dev/null
+++ b/ricochet/include/ricochet/core/link_hints.hh
@@ -0,0 +1,27 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+
+#pragma once
+
+#include "ricochet/core/types.hh"
+#include "ricochet/tui/terminal.hh"
+#include <string>
+
+namespace ricochet::core {
+
+std::string index_to_hint( std::size_t index );
+void toggle_link_hints( PageData& page_data, bool show );
+void handle_follow_link( const tui::Terminal& terminal,
+                         PageData& page_data,
+                         std::string& current_url,
+                         std::size_t& scroll_y,
+                         bool& navigate );
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/local_data.hh b/ricochet/include/ricochet/core/local_data.hh
new file mode 100644
index 0000000..ca07846
--- /dev/null
+++ b/ricochet/include/ricochet/core/local_data.hh
@@ -0,0 +1,32 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ricochet::core {
+
+std::string get_config_path( const std::string& filename );
+void save_bookmark( const std::string& title, const std::string& url );
+std::string generate_bookmarks_html();
+void append_to_history( const std::string& url, const std::string& title );
+std::string generate_history_html();
+std::string generate_help_html();
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/page_loader.hh b/ricochet/include/ricochet/core/page_loader.hh
new file mode 100644
index 0000000..11131e2
--- /dev/null
+++ b/ricochet/include/ricochet/core/page_loader.hh
@@ -0,0 +1,32 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/core/types.hh"
+// #include "ricochet/net/http_client.hh"
+// #include "ricochet/parser/dom_tree.hh"
+// #include <string>
+
+namespace ricochet::core {
+
+// std::string extract_title( const parser::DomNode& root_node );
+// PageData process_binary_download( const HttpRequest& req, const net::HttpResponse& resp );
+PageData load_page( const HttpRequest& req );
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/page_processor.hh b/ricochet/include/ricochet/core/page_processor.hh
new file mode 100644
index 0000000..8f40d3a
--- /dev/null
+++ b/ricochet/include/ricochet/core/page_processor.hh
@@ -0,0 +1,32 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/core/types.hh"
+#include "ricochet/net/http_client.hh"
+#include "ricochet/parser/dom_tree.hh"
+#include <string>
+
+namespace ricochet::core {
+
+std::string extract_title( const parser::DomNode& root_node );
+
+PageData process_binary_download( const HttpRequest& req, const net::HttpResponse& resp );
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/search_handler.hh b/ricochet/include/ricochet/core/search_handler.hh
new file mode 100644
index 0000000..7053be8
--- /dev/null
+++ b/ricochet/include/ricochet/core/search_handler.hh
@@ -0,0 +1,23 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+
+#pragma once
+
+#include "ricochet/core/types.hh"
+#include <cstddef>
+#include <string>
+
+namespace ricochet::core {
+
+void find_search_matches( PageData& page_data, const std::string& query );
+void apply_search_highlight( PageData& page_data, const std::string& query );
+void execute_search( PageData& page_data, const std::string& query, std::size_t& scroll_y, bool next_match );
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/types.hh b/ricochet/include/ricochet/core/types.hh
new file mode 100644
index 0000000..bd7e819
--- /dev/null
+++ b/ricochet/include/ricochet/core/types.hh
@@ -0,0 +1,54 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/render/renderer.hh"
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace ricochet::core {
+
+struct PageData
+{
+  std::vector<std::string> lines;
+  std::vector<std::string> links;
+  std::vector<render::InputField> inputs;
+  std::string title;
+  std::vector<std::string> original_lines {};
+  std::string last_search {};
+  std::size_t current_match_idx { 0 };
+  std::vector<std::size_t> match_lines {};
+};
+
+struct HttpRequest
+{
+  std::string url {};
+  std::string method = "GET";
+  std::string body {};
+};
+
+enum class InputAction : std::uint8_t
+{
+  None,
+  Quit,
+  Navigate
+};
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/ui_input.hh b/ricochet/include/ricochet/core/ui_input.hh
new file mode 100644
index 0000000..bf71685
--- /dev/null
+++ b/ricochet/include/ricochet/core/ui_input.hh
@@ -0,0 +1,29 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/tui/terminal.hh"
+#include <string>
+
+namespace ricochet::core {
+
+std::string get_url_input( const tui::Terminal& terminal );
+std::string get_terminal_input( const tui::Terminal& terminal, const std::string& prompt );
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/ui_view.hh b/ricochet/include/ricochet/core/ui_view.hh
new file mode 100644
index 0000000..d9a55fa
--- /dev/null
+++ b/ricochet/include/ricochet/core/ui_view.hh
@@ -0,0 +1,37 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/tui/terminal.hh"
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ricochet::core {
+
+std::string build_footer( std::string_view url, std::size_t width );
+
+void draw_view( const tui::Terminal& terminal,
+                const std::vector<std::string>& lines,
+                std::size_t scroll_y,
+                std::string_view url,
+                std::string_view title );
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/core/utils.hh b/ricochet/include/ricochet/core/utils.hh
new file mode 100644
index 0000000..d9f58dd
--- /dev/null
+++ b/ricochet/include/ricochet/core/utils.hh
@@ -0,0 +1,32 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace ricochet::core {
+
+std::vector<std::string> split_into_lines( const std::string& text );
+std::string normalize_url( const std::string& target, const std::string& current_url );
+std::string strip_ddg_tracker( std::string target );
+std::vector<std::string> wrap_lines( const std::vector<std::string>& original_lines, std::size_t wrap_width );
+
+} // namespace ricochet::core
diff --git a/ricochet/include/ricochet/net/config.hh b/ricochet/include/ricochet/net/config.hh
new file mode 100644
index 0000000..fa73193
--- /dev/null
+++ b/ricochet/include/ricochet/net/config.hh
@@ -0,0 +1,35 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ricochet::net {
+
+std::string get_config_path( const std::string& filename );
+
+struct BrowserConfig
+{
+  std::string user_agent;
+  std::string homepage;
+};
+
+BrowserConfig& get_browser_config();
+
+} // namespace ricochet::net
diff --git a/ricochet/include/ricochet/net/cookie_jar.hh b/ricochet/include/ricochet/net/cookie_jar.hh
new file mode 100644
index 0000000..5c5befb
--- /dev/null
+++ b/ricochet/include/ricochet/net/cookie_jar.hh
@@ -0,0 +1,35 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+namespace ricochet::net {
+
+using CookieJar = std::unordered_map<std::string, std::unordered_map<std::string, std::string>>;
+
+void load_cookies_from_file( CookieJar& jar );
+CookieJar& get_cookie_jar();
+void save_cookies_to_file( const CookieJar& jar );
+
+void update_cookies( const std::string& raw_response, const std::string& host );
+std::string build_cookie_header( const std::string& host );
+
+} // namespace ricochet::net
diff --git a/ricochet/include/ricochet/net/http_client.hh b/ricochet/include/ricochet/net/http_client.hh
index f6d8aa3..f57cbcf 100644
--- a/ricochet/include/ricochet/net/http_client.hh
+++ b/ricochet/include/ricochet/net/http_client.hh
@@ -53,7 +53,8 @@ public:
    * @return Returns HttpResponse on success, returns an error message string on failure
    */
   std::expected<HttpResponse, std::string> fetch( std::string_view url,
-                                                  std::string_view method = "GET",
+                                                  std::string_view method
+                                                  = "GET", // NOLINT(bugprone-easily-swappable-parameters)
                                                   std::string_view body = "" ) const;
 
 private:
diff --git a/ricochet/include/ricochet/net/http_utils.hh b/ricochet/include/ricochet/net/http_utils.hh
new file mode 100644
index 0000000..3d96e79
--- /dev/null
+++ b/ricochet/include/ricochet/net/http_utils.hh
@@ -0,0 +1,30 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+#include <string_view>
+
+namespace ricochet::net {
+
+std::string dechunk( std::string_view body );
+std::string remove_html_comments( std::string html );
+std::string remove_tag_blocks( std::string html, const std::string& tag_name );
+
+} // namespace ricochet::net
diff --git a/ricochet/include/ricochet/net/url_parser.hh b/ricochet/include/ricochet/net/url_parser.hh
new file mode 100644
index 0000000..039e4dc
--- /dev/null
+++ b/ricochet/include/ricochet/net/url_parser.hh
@@ -0,0 +1,37 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <expected>
+#include <string>
+#include <string_view>
+
+namespace ricochet::net {
+
+struct ParsedUrl
+{
+  std::string host {};
+  std::string path {};
+};
+
+std::expected<ParsedUrl, std::string> parse_url( std::string_view url );
+
+std::string extract_redirect_url( const std::string& raw_response, bool is_https, const std::string& host );
+
+} // namespace ricochet::net
diff --git a/ricochet/include/ricochet/render/input_renderer.hh b/ricochet/include/ricochet/render/input_renderer.hh
new file mode 100644
index 0000000..0114673
--- /dev/null
+++ b/ricochet/include/ricochet/render/input_renderer.hh
@@ -0,0 +1,34 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/parser/dom_tree.hh"
+#include "ricochet/render/renderer.hh"
+#include <string>
+
+namespace ricochet::render {
+
+struct FormContext;
+
+void render_input_node( const parser::DomNode& node,
+                        RenderResult& result,
+                        const FormContext& ctx,
+                        std::string& output );
+
+} // namespace ricochet::render
diff --git a/ricochet/include/ricochet/render/internal.hh b/ricochet/include/ricochet/render/internal.hh
new file mode 100644
index 0000000..5e7cac0
--- /dev/null
+++ b/ricochet/include/ricochet/render/internal.hh
@@ -0,0 +1,35 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/parser/dom_tree.hh"
+#include "ricochet/render/renderer.hh"
+#include <string>
+
+namespace ricochet::render {
+
+struct FormContext
+{
+  std::string action;
+  std::string method;
+};
+
+void render_node( const parser::DomNode& node, RenderResult& result, FormContext ctx );
+
+} // namespace ricochet::render
diff --git a/ricochet/include/ricochet/render/table_renderer.hh b/ricochet/include/ricochet/render/table_renderer.hh
new file mode 100644
index 0000000..5efc42c
--- /dev/null
+++ b/ricochet/include/ricochet/render/table_renderer.hh
@@ -0,0 +1,30 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ricochet/parser/dom_tree.hh"
+#include "ricochet/render/renderer.hh"
+
+namespace ricochet::render {
+
+struct FormContext;
+
+void render_table( const parser::DomNode& node, RenderResult& result, const FormContext& ctx );
+
+} // namespace ricochet::render
diff --git a/ricochet/include/ricochet/render/utils.hh b/ricochet/include/ricochet/render/utils.hh
new file mode 100644
index 0000000..38b3022
--- /dev/null
+++ b/ricochet/include/ricochet/render/utils.hh
@@ -0,0 +1,33 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+#include <string_view>
+
+namespace ricochet::render {
+
+std::string decode_entities( std::string text );
+std::string extract_attr( const std::string& tag_name, std::string_view attr_name );
+std::size_t get_visible_length( std::string_view str );
+
+bool is_ignored_tag( std::string_view tag );
+bool is_heading_tag( std::string_view tag );
+
+} // namespace ricochet::render
diff --git a/ricochet/src/core/browser.cc b/ricochet/src/core/browser.cc
index c4dbb08..86a5096 100644
--- a/ricochet/src/core/browser.cc
+++ b/ricochet/src/core/browser.cc
@@ -17,843 +17,26 @@
  */
 
 #include "ricochet/core/browser.hh"
-#include "ricochet/net/http_client.hh"
-#include "ricochet/parser/html_lexer.hh"
-#include "ricochet/parser/tree_builder.hh"
-#include "ricochet/render/renderer.hh"
-#include "ricochet/tui/terminal.hh"
+
 #include <cstddef>
 #include <cstdlib>
-#include <exception>
 #include <fstream>
 #include <iostream>
-#include <ranges>
 #include <sys/stat.h>
 
-namespace ricochet::core {
+#include "ricochet/core/form_handler.hh"
+#include "ricochet/core/link_hints.hh"
+#include "ricochet/core/local_data.hh"
+#include "ricochet/core/page_loader.hh"
+#include "ricochet/core/search_handler.hh"
+#include "ricochet/core/ui_input.hh"
+#include "ricochet/core/ui_view.hh"
+#include "ricochet/core/utils.hh"
 
-struct PageData
-{
-  std::vector<std::string> lines;
-  std::vector<std::string> links;
-  std::vector<render::InputField> inputs;
-  std::string title;
-  std::vector<std::string> original_lines {};
-  std::string last_search {};
-  std::size_t current_match_idx { 0 };
-  std::vector<std::size_t> match_lines {};
-};
-
-struct HttpRequest
-{
-  std::string url {};
-  std::string method = "GET";
-  std::string body {};
-};
+namespace ricochet::core {
 
 namespace {
 
-std::string get_config_path( const std::string& filename )
-{
-  const char* home = std::getenv( "HOME" ); // NOLINT(concurrency-mt-unsafe)
-  const std::string dir = ( home != nullptr ) ? std::string( home ) + "/.ricochet" : ".ricochet";
-  static_cast<void>( mkdir( dir.c_str(), 0755 ) );
-  return dir + "/" + filename;
-}
-
-std::string extract_title( const parser::DomNode& root_node )
-{
-  std::vector<const parser::DomNode*> stack;
-  stack.push_back( &root_node );
-
-  while ( !stack.empty() ) {
-    const parser::DomNode* current = stack.back();
-    stack.pop_back();
-
-    std::string base_tag = current->tag_name;
-    const std::size_t space_pos = base_tag.find( ' ' );
-    if ( space_pos != std::string::npos ) {
-      base_tag = base_tag.substr( 0, space_pos );
-    }
-
-    for ( char& c : base_tag ) {
-      if ( c >= 'A' && c <= 'Z' ) {
-        c = static_cast<char>( c + 32 );
-      }
-    }
-
-    if ( base_tag == "title" ) {
-      std::string full_title;
-      for ( const auto& child : current->children ) {
-        if ( child.tag_name.empty() ) {
-          full_title += child.text_content;
-        }
-      }
-      if ( !full_title.empty() ) {
-        return full_title;
-      }
-    }
-
-    for ( const auto& child : std::ranges::reverse_view( current->children ) ) {
-      stack.push_back( &child );
-    }
-  }
-  return "";
-}
-
-void save_bookmark( const std::string& title, // NOLINT(bugprone-easily-swappable-parameters)
-                    const std::string& url )
-{
-  if ( url == "ricochet://bookmarks" ) {
-    return;
-  }
-  std::ofstream file( get_config_path( "bookmarks.txt" ), std::ios::app );
-  if ( !file.is_open() ) {
-    return;
-  }
-
-  std::string safe_title = title;
-  if ( safe_title.empty() ) {
-    safe_title = url;
-  }
-  for ( char& c : safe_title ) {
-    if ( c == '\n' || c == '\r' || c == '\t' ) {
-      c = ' ';
-    }
-  }
-  file << url << '\t' << safe_title << '\n';
-}
-
-std::string generate_bookmarks_html()
-{
-  std::ifstream file( get_config_path( "bookmarks.txt" ) );
-  std::string html = "<html><head><title>My Bookmarks</title></head><body><h1>Saved Bookmarks</h1><ul>";
-  if ( !file.is_open() ) {
-    html += "<li>No bookmarks found. Press 'b' on any page to add one!</li>";
-  } else {
-    std::string line;
-    while ( std::getline( file, line ) ) {
-      const std::size_t tab_pos = line.find( '\t' );
-      if ( tab_pos != std::string::npos ) {
-        const std::string url = line.substr( 0, tab_pos );
-        const std::string title = line.substr( tab_pos + 1 );
-        html += "<li><a href=\"";
-        html += url;
-        html += "\">[Link] ";
-        html += title;
-        html += "</a></li>";
-      }
-    }
-  }
-  html += "</ul></body></html>";
-  return html;
-}
-
-void append_to_history( const std::string& url, // NOLINT(bugprone-easily-swappable-parameters)
-                        const std::string& title )
-{
-  if ( url.starts_with( "ricochet://" ) ) {
-    return;
-  }
-  std::ofstream file( get_config_path( "history.txt" ), std::ios::app );
-  if ( !file.is_open() ) {
-    return;
-  }
-
-  std::string safe_title = title;
-  if ( safe_title.empty() ) {
-    safe_title = url;
-  }
-  for ( char& c : safe_title ) {
-    if ( c == '\n' || c == '\r' || c == '\t' ) {
-      c = ' ';
-    }
-  }
-  file << url << '\t' << safe_title << '\n';
-}
-
-std::string generate_history_html()
-{
-  std::ifstream file( get_config_path( "history.txt" ) );
-  std::string html = "<html><head><title>History</title></head><body><h1>Browsing History</h1><ul>";
-  if ( !file.is_open() ) {
-    html += "<li>No history found. Start browsing!</li>";
-  } else {
-    std::vector<std::string> lines;
-    std::string line;
-    while ( std::getline( file, line ) ) {
-      lines.push_back( std::move( line ) );
-    }
-
-    std::size_t count = 0;
-    for ( auto it = lines.rbegin(); it != lines.rend() && count < 100; ++it, ++count ) {
-      const std::size_t tab_pos = it->find( '\t' );
-      if ( tab_pos != std::string::npos ) {
-        const std::string url = it->substr( 0, tab_pos );
-        const std::string title = it->substr( tab_pos + 1 );
-        html += "<li><a href=\"";
-        html += url;
-        html += "\">[Link] ";
-        html += title;
-        html += "</a></li>";
-      }
-    }
-  }
-  html += "</ul></body></html>";
-  return html;
-}
-
-std::string generate_help_html()
-{
-  return R"(<html>
-  <head><title>Ricochet Help Manual</title></head>
-  <body>
-    <h1>Ricochet User Manual</h1>
-    <h2>1. Navigation & Browsing</h2>
-    <ul>
-      <li><b>j / k</b> : Scroll down / up</li>
-      <li><b>H / L</b> : History backward / forward</li>
-      <li><b>/</b> : Open prompt to enter a new URL</li>
-    </ul>
-    <h2>2. Page Interaction</h2>
-    <ul>
-      <li><b>f</b> : Toggle Link Hints (type the two letters to follow a link instantly)</li>
-      <li><b>n</b> : Find in page (search for text)</li>
-      <li><b>N</b> : Jump to the next search match</li>
-      <li><b>i</b> : Enter form input mode (fill textboxes, click buttons, toggle checkboxes)</li>
-    </ul>
-    <h2>3. Bookmarks & History</h2>
-    <ul>
-      <li><b>b</b> : Bookmark the current page</li>
-      <li><b>B</b> : View all saved bookmarks</li>
-      <li><b>h</b> : View browsing history</li>
-    </ul>
-    <h2>4. System</h2>
-    <ul>
-      <li><b>?</b> : Show this help manual</li>
-      <li><b>q</b> : Quit Ricochet</li>
-    </ul>
-  </body>
-  </html>)";
-}
-
-PageData process_binary_download( const HttpRequest& req, const net::HttpResponse& resp )
-{
-  std::string fname = "download.dat";
-  const std::size_t slash = req.url.rfind( '/' );
-  if ( slash != std::string::npos && slash + 1 < req.url.length() ) {
-    fname = req.url.substr( slash + 1 );
-    const std::size_t q_pos = fname.find( '?' );
-    if ( q_pos != std::string::npos ) {
-      fname = fname.substr( 0, q_pos );
-    }
-  }
-  if ( fname.empty() ) {
-    fname = "download.dat";
-  }
-
-  std::ofstream out( fname, std::ios::binary );
-  out.write( resp.body.data(), static_cast<std::streamsize>( resp.body.size() ) );
-  out.close();
-
-  return { .lines = { "\033[1;32m[ Download Complete ]\033[0m",
-                      "",
-                      "Saved File : " + fname,
-                      "File Type  : " + resp.content_type,
-                      "File Size  : " + std::to_string( resp.body.size() ) + " bytes",
-                      "",
-                      "Press 'H' to return to the previous page." },
-           .links = {},
-           .inputs = {},
-           .title = "Download Manager" };
-}
-
-std::vector<std::string> split_into_lines( const std::string& text )
-{
-  std::vector<std::string> lines;
-  std::size_t start = 0;
-  while ( start < text.length() ) {
-    const std::size_t end = text.find( '\n', start );
-    if ( end == std::string::npos ) {
-      lines.push_back( text.substr( start ) );
-      break;
-    }
-    lines.push_back( text.substr( start, end - start ) );
-    start = end + 1;
-  }
-  return lines;
-}
-
-PageData load_page( const HttpRequest& req )
-{
-  std::string html_body;
-  if ( req.url == "ricochet://bookmarks" ) {
-    html_body = generate_bookmarks_html();
-  } else if ( req.url == "ricochet://history" ) {
-    html_body = generate_history_html();
-  } else if ( req.url == "ricochet://help" ) {
-    html_body = generate_help_html();
-  } else {
-    const net::HttpClient client;
-    auto response_result = client.fetch( req.url, req.method, req.body );
-    if ( !response_result.has_value() ) {
-      return { .lines
-               = { "\033[1;31m[!] Failed to load:\033[0m " + req.url, "", "Reason: " + response_result.error() },
-               .links = {},
-               .inputs = {},
-               .title = "Error" };
-    }
-
-    const auto& resp = response_result.value();
-    std::string c_type = resp.content_type;
-    for ( char& c : c_type ) {
-      if ( c >= 'A' && c <= 'Z' ) {
-        c = static_cast<char>( c + 32 );
-      }
-    }
-
-    const bool is_text
-      = c_type.starts_with( "text/" ) || c_type.contains( "xml" ) || c_type.contains( "json" ) || c_type.empty();
-
-    if ( !is_text ) {
-      return process_binary_download( req, resp );
-    }
-    html_body = response_result.value().body;
-  }
-
-  const parser::HtmlLexer lexer;
-  const parser::TreeBuilder builder;
-  const render::Renderer renderer;
-
-  const auto dom_root = builder.build( lexer.tokenize( html_body ) );
-  const render::RenderResult result = renderer.render( dom_root );
-  const std::string title = extract_title( dom_root );
-
-  return {
-    .lines = split_into_lines( result.text ), .links = result.links, .inputs = result.inputs, .title = title };
-}
-
-std::string build_footer( std::string_view url, std::size_t width )
-{
-  const std::string_view keys
-    = " | [j/k]Scroll [n/N]Find [/]Nav [f]Hint [i]In [r]Ref [H/L]Back [h]Hist [b/B]Mark [?]Help [q]Quit ";
-  const std::string_view prefix = " URL: ";
-
-  std::string footer;
-  if ( width <= keys.length() + prefix.length() + 3 ) {
-    footer.reserve( prefix.length() + url.length() + keys.length() );
-    footer += prefix;
-    footer += url;
-    footer += keys;
-    if ( footer.length() > width && width > 3 ) {
-      footer.erase( width - 3 );
-      footer += "...";
-    }
-  } else {
-    const std::size_t max_url_len = width - keys.length() - prefix.length();
-    footer.reserve( width );
-    footer += prefix;
-    if ( url.length() > max_url_len ) {
-      footer += url.substr( 0, max_url_len - 3 );
-      footer += "...";
-    } else {
-      footer += url;
-    }
-    footer += keys;
-  }
-
-  if ( footer.length() < width ) {
-    footer.append( width - footer.length(), ' ' );
-  }
-  return footer;
-}
-
-void draw_view( const tui::Terminal& terminal,
-                const std::vector<std::string>& lines,
-                std::size_t scroll_y,
-                std::string_view url,    // NOLINT(bugprone-easily-swappable-parameters)
-                std::string_view title ) // NOLINT(bugprone-easily-swappable-parameters)
-{
-  terminal.clear_screen();
-  auto [width, height] = terminal.get_size();
-  const std::size_t usable_height = ( height > 2 ) ? ( height - 2 ) : 1;
-
-  std::string clean_title( title );
-  if ( clean_title.empty() ) {
-    const std::size_t start = url.find( "://" );
-    const std::size_t host_start = ( start == std::string::npos ) ? 0 : start + 3;
-    const std::size_t host_end = url.find( '/', host_start );
-    clean_title = std::string( url.substr( host_start, host_end - host_start ) );
-  }
-  for ( char& c : clean_title ) {
-    if ( c == '\n' || c == '\r' ) {
-      c = ' ';
-    }
-  }
-
-  std::string header = " PAGE: " + clean_title;
-  if ( header.size() < width ) {
-    header.append( width - header.size(), ' ' );
-  } else if ( header.size() > width && width > 3 ) {
-    header = header.substr( 0, width - 3 ) + "...";
-  }
-  std::cout << "\033[7m" << header << "\033[0m\r\n";
-
-  for ( std::size_t i = 0; i < usable_height; ++i ) {
-    if ( scroll_y + i < lines.size() ) {
-      std::cout << lines[scroll_y + i] << "\r\n";
-    } else {
-      std::cout << "~\r\n";
-    }
-  }
-
-  const std::string footer = build_footer( url, width );
-  std::cout << "\033[7m" << footer << "\033[0m";
-  std::cout.flush();
-}
-
-std::string get_url_input( const tui::Terminal& terminal )
-{
-  auto [width, height] = terminal.get_size();
-  terminal.move_cursor( height, 1 );
-  std::cout << "\x1b[2K\033[7m URL: \033[0m ";
-  std::cout.flush();
-
-  std::string input;
-  terminal.show_cursor( true );
-  while ( true ) {
-    const char ch = terminal.read_key();
-    if ( ch == '\r' || ch == '\n' ) {
-      break;
-    }
-    if ( ch == 27 ) {
-      input.clear();
-      break;
-    }
-    if ( ch == 127 || ch == 8 ) {
-      if ( !input.empty() ) {
-        input.pop_back();
-        std::cout << "\b \b";
-        std::cout.flush();
-      }
-    } else if ( std::isprint( static_cast<unsigned char>( ch ) ) ) {
-      input += ch;
-      std::cout << ch;
-      std::cout.flush();
-    }
-  }
-  terminal.show_cursor( false );
-
-  return Browser::format_url( std::move( input ) );
-}
-
-// std::string get_link_input( const tui::Terminal& terminal )
-// {
-//   auto [width, height] = terminal.get_size();
-//   terminal.move_cursor( height, 1 );
-//   std::cout << "\x1b[2K\033[7m Follow Link [#]: \033[0m ";
-//   std::cout.flush();
-
-//   std::string num_input;
-//   terminal.show_cursor( true );
-//   while ( true ) {
-//     const char ch = terminal.read_key();
-//     if ( ch == '\r' || ch == '\n' ) {
-//       break;
-//     }
-//     if ( ch == 27 ) {
-//       num_input.clear();
-//       break;
-//     }
-//     if ( ch == 127 || ch == 8 ) {
-//       if ( !num_input.empty() ) {
-//         num_input.pop_back();
-//         std::cout << "\b \b";
-//         std::cout.flush();
-//       }
-//     } else if ( std::isdigit( static_cast<unsigned char>( ch ) ) ) {
-//       num_input += ch;
-//       std::cout << ch;
-//       std::cout.flush();
-//     }
-//   }
-//   terminal.show_cursor( false );
-//   return num_input;
-// }
-
-std::string normalize_url( const std::string& target, const std::string& current_url )
-{
-  if ( target.starts_with( "/" ) ) {
-    if ( target.starts_with( "//" ) ) {
-      return "https:" + target;
-    }
-    const std::size_t slash_pos = current_url.find( '/', 8 );
-    const std::string domain
-      = ( slash_pos == std::string::npos ) ? current_url : current_url.substr( 0, slash_pos );
-    return domain + target;
-  }
-  if ( !target.starts_with( "http" ) ) {
-    const std::size_t last_slash = current_url.rfind( '/' );
-    if ( last_slash > 7 ) {
-      return current_url.substr( 0, last_slash + 1 ) + target;
-    }
-    return current_url + "/" + target;
-  }
-  return target;
-}
-
-std::string strip_ddg_tracker( std::string target )
-{
-  const std::size_t uddg_pos = target.find( "uddg=" );
-  if ( uddg_pos != std::string::npos ) {
-    const std::size_t end_pos = target.find( '&', uddg_pos );
-    const std::string encoded = target.substr( uddg_pos + 5, end_pos - ( uddg_pos + 5 ) );
-    std::string decoded;
-    for ( std::size_t i = 0; i < encoded.length(); ++i ) {
-      if ( encoded[i] == '%' && i + 2 < encoded.length() ) {
-        const std::string hex = encoded.substr( i + 1, 2 );
-        try {
-          decoded += static_cast<char>( std::stoi( hex, nullptr, 16 ) );
-        } catch ( const std::exception& ) {
-          (void)0;
-        }
-        i += 2;
-      } else {
-        decoded += encoded[i];
-      }
-    }
-    return decoded;
-  }
-  return target;
-}
-
-std::string index_to_hint( std::size_t index )
-{
-  const std::string alphabet = "asdfghjklqwertyuiopzxcvbnm";
-  std::string hint;
-  hint += alphabet[( index / alphabet.length() ) % alphabet.length()];
-  hint += alphabet[index % alphabet.length()];
-  return hint;
-}
-
-void toggle_link_hints( PageData& page_data, bool show )
-{
-  const std::string hl_start = "\033[0;1;35;7m ";
-  const std::string hl_end = " \033[0m";
-
-  std::vector<std::string> formatted_hints;
-  if ( show ) {
-    formatted_hints.reserve( page_data.links.size() );
-    for ( std::size_t i = 0; i < page_data.links.size(); ++i ) {
-      std::string h = hl_start;
-      h += index_to_hint( i );
-      h += hl_end;
-      formatted_hints.push_back( std::move( h ) );
-    }
-  }
-
-  for ( auto& line : page_data.lines ) {
-    for ( std::size_t i = 0; i < page_data.links.size(); ++i ) {
-      const std::string marker = "{L:" + std::to_string( i + 1 ) + "}";
-      const std::size_t pos = line.find( marker );
-      if ( pos != std::string::npos ) {
-        if ( show ) {
-          line.replace( pos, marker.length(), formatted_hints[i] );
-        } else {
-          const std::size_t end_pos = line.find( hl_end, pos );
-          if ( end_pos != std::string::npos ) {
-            line.replace( pos, end_pos + hl_end.length() - pos, marker );
-          }
-        }
-      }
-    }
-  }
-}
-
-void handle_follow_link( const tui::Terminal& terminal,
-                         PageData& page_data,
-                         std::string& current_url,
-                         std::size_t& scroll_y, // NOLINT(bugprone-easily-swappable-parameters)
-                         bool& navigate )
-{
-  toggle_link_hints( page_data, true );
-
-  draw_view( terminal, page_data.lines, scroll_y, current_url, page_data.title );
-
-  auto [w, h] = terminal.get_size();
-  terminal.move_cursor( h, 1 );
-  std::cout << "\x1b[2K\033[1;35;7m Follow Hint (2 keys): \033[0m ";
-  std::cout.flush();
-
-  std::string input;
-  input += terminal.read_key();
-  std::cout << input[0];
-  std::cout.flush();
-  input += terminal.read_key();
-
-  bool found = false;
-  for ( std::size_t i = 0; i < page_data.links.size(); ++i ) {
-    if ( index_to_hint( i ) == input ) {
-      std::string target = page_data.links[i];
-      target = normalize_url( target, current_url );
-      target = strip_ddg_tracker( target );
-      current_url = target;
-      navigate = true;
-      found = true;
-      break;
-    }
-  }
-
-  if ( !found ) {
-    toggle_link_hints( page_data, false );
-  }
-}
-
-enum class InputAction : std::uint8_t
-{
-  None,
-  Quit,
-  Navigate
-};
-
-std::string get_terminal_input( const tui::Terminal& terminal, const std::string& prompt )
-{
-  auto [width, height] = terminal.get_size();
-  terminal.move_cursor( height, 1 );
-  std::cout << "\x1b[2K\033[7m " << prompt << " \033[0m ";
-  std::cout.flush();
-
-  std::string input;
-  terminal.show_cursor( true );
-  while ( true ) {
-    const char ch = terminal.read_key();
-    if ( ch == '\r' || ch == '\n' ) {
-      break;
-    }
-    if ( ch == 27 ) {
-      input.clear();
-      break;
-    }
-    if ( ch == 127 || ch == 8 ) {
-      if ( !input.empty() ) {
-        input.pop_back();
-        std::cout << "\b \b";
-        std::cout.flush();
-      }
-    } else if ( std::isprint( static_cast<unsigned char>( ch ) ) ) {
-      input += ch;
-      std::cout << ch;
-      std::cout.flush();
-    }
-  }
-  terminal.show_cursor( false );
-  return input;
-}
-
-InputAction submit_form( const render::InputField& target_input,
-                         const std::vector<render::InputField>& inputs,
-                         const std::string& current_url,
-                         std::vector<HttpRequest>& history,
-                         std::size_t& history_idx )
-{
-  std::string body;
-  for ( const auto& in : inputs ) {
-    if ( in.action == target_input.action && !in.name.empty() && in.type != "submit" && in.type != "button" ) {
-      if ( ( in.type == "checkbox" || in.type == "radio" ) && !in.checked ) {
-        continue;
-      }
-      std::string encoded = in.value;
-      for ( char& ch : encoded ) {
-        if ( ch == ' ' ) {
-          ch = '+';
-        }
-      }
-      if ( !body.empty() ) {
-        body += "&";
-      }
-      body += in.name + "=" + encoded;
-    }
-  }
-  const std::string action
-    = target_input.action.empty() ? current_url : normalize_url( target_input.action, current_url );
-  HttpRequest next_req { .url = action, .method = "GET", .body = "" };
-  if ( target_input.method == "post" || target_input.method == "POST" ) {
-    next_req.method = "POST";
-    next_req.body = body;
-  } else {
-    const char sep = action.contains( '?' ) ? '&' : '?';
-    next_req.url += sep + body;
-  }
-  history.resize( history_idx + 1 );
-  history.push_back( next_req );
-  history_idx++;
-  return InputAction::Navigate;
-}
-
-void find_search_matches( PageData& page_data, const std::string& query )
-{
-  page_data.last_search = query;
-  page_data.match_lines.clear();
-  page_data.current_match_idx = 0;
-  for ( std::size_t i = 0; i < page_data.original_lines.size(); ++i ) {
-    if ( page_data.original_lines[i].find( query ) != std::string::npos ) {
-      page_data.match_lines.push_back( i );
-    }
-  }
-}
-
-void apply_search_highlight( PageData& page_data, const std::string& query )
-{
-  page_data.lines = page_data.original_lines;
-  if ( page_data.match_lines.empty() ) {
-    return;
-  }
-
-  const std::string hl_start = "\033[43;30m";
-  const std::string hl_end = "\033[0m";
-
-  for ( const auto match_idx : page_data.match_lines ) {
-    auto& line = page_data.lines[match_idx];
-    std::size_t pos = 0;
-    std::string replacement;
-    replacement.reserve( hl_start.length() + query.length() + hl_end.length() );
-    replacement += hl_start;
-    replacement += query;
-    replacement += hl_end;
-    while ( ( pos = line.find( query, pos ) ) != std::string::npos ) {
-      line.replace( pos, query.length(), replacement );
-      pos += hl_start.length() + query.length() + hl_end.length();
-    }
-  }
-}
-
-void execute_search( PageData& page_data, const std::string& query, std::size_t& scroll_y, bool next_match )
-{
-  if ( query.empty() ) {
-    return;
-  }
-
-  if ( !next_match || query != page_data.last_search ) {
-    find_search_matches( page_data, query );
-    apply_search_highlight( page_data, query );
-  } else if ( !page_data.match_lines.empty() ) {
-    page_data.current_match_idx = ( page_data.current_match_idx + 1 ) % page_data.match_lines.size();
-  }
-
-  if ( page_data.match_lines.empty() ) {
-    return;
-  }
-
-  const std::size_t target_line = page_data.match_lines[page_data.current_match_idx];
-  scroll_y = ( target_line > 5 ) ? ( target_line - 5 ) : 0;
-}
-
-void update_input_value( PageData& page_data, std::size_t index, const std::string& query )
-{
-  page_data.inputs[index - 1].value = query;
-  const std::string marker = "[I" + std::to_string( index ) + ":";
-  const std::string replacement = "[I" + std::to_string( index ) + ":" + query + "]";
-
-  auto update_lines = [&]( std::vector<std::string>& lines_arr ) {
-    for ( auto& line : lines_arr ) {
-      const std::size_t pos = line.find( marker );
-      if ( pos != std::string::npos ) {
-        const std::size_t end = line.find( ']', pos );
-        if ( end != std::string::npos ) {
-          line.replace( pos, end - pos + 1, replacement );
-        }
-      }
-    }
-  };
-  update_lines( page_data.lines );
-  update_lines( page_data.original_lines );
-}
-
-void update_single_line_ui( std::string& line, const std::string& marker, const render::InputField& in )
-{
-  const std::size_t pos = line.find( marker );
-  if ( pos == std::string::npos ) {
-    return;
-  }
-  const std::size_t end = line.find( ']', pos );
-  if ( end == std::string::npos ) {
-    return;
-  }
-
-  std::string prefix;
-  if ( in.type == "checkbox" ) {
-    prefix = in.checked ? "[X] " : "[ ] ";
-  } else {
-    prefix = in.checked ? "(X) " : "( ) ";
-  }
-  line.replace( pos, end - pos + 1, marker + prefix + in.value + "]" );
-}
-
-void update_toggle_ui( PageData& page_data )
-{
-  for ( std::size_t i = 0; i < page_data.inputs.size(); ++i ) {
-    const auto& in = page_data.inputs[i];
-    if ( in.type != "checkbox" && in.type != "radio" ) {
-      continue;
-    }
-    const std::string marker = "[I" + std::to_string( i + 1 ) + ":";
-    for ( auto& line : page_data.lines ) {
-      update_single_line_ui( line, marker, in );
-    }
-    for ( auto& line : page_data.original_lines ) {
-      update_single_line_ui( line, marker, in );
-    }
-  }
-}
-
-InputAction handle_form_input( const tui::Terminal& terminal,
-                               PageData& page_data,
-                               const std::string& current_url,
-                               std::vector<HttpRequest>& history,
-                               std::size_t& history_idx )
-{
-  const std::string num_input = get_terminal_input( terminal, "Select Input [#]:" );
-  if ( num_input.empty() ) {
-    return InputAction::None;
-  }
-  std::size_t index = 0;
-  try {
-    index = std::stoul( num_input );
-  } catch ( ... ) {
-    return InputAction::None;
-  }
-  if ( index == 0 || index > page_data.inputs.size() ) {
-    return InputAction::None;
-  }
-
-  auto& target_input = page_data.inputs[index - 1];
-  if ( target_input.type == "submit" || target_input.type == "button" ) {
-    return submit_form( target_input, page_data.inputs, current_url, history, history_idx );
-  }
-
-  if ( target_input.type == "checkbox" || target_input.type == "radio" ) {
-    if ( target_input.type == "radio" ) {
-      for ( auto& in : page_data.inputs ) {
-        if ( in.name == target_input.name && in.action == target_input.action ) {
-          in.checked = false;
-        }
-      }
-      target_input.checked = true;
-    } else {
-      target_input.checked = !target_input.checked;
-    }
-    update_toggle_ui( page_data );
-    return InputAction::None;
-  }
-
-  const std::string query = get_terminal_input( terminal, "Enter Text [I" + std::to_string( index ) + "]:" );
-  if ( query.empty() ) {
-    return InputAction::None;
-  }
-  update_input_value( page_data, index, query );
-  return InputAction::None;
-}
-
 InputAction push_history( const std::string& url, std::vector<HttpRequest>& history, std::size_t& history_idx )
 {
   history.resize( history_idx + 1 );
@@ -944,39 +127,6 @@ InputAction process_key( char c,
   return InputAction::None;
 }
 
-std::vector<std::string> wrap_lines( const std::vector<std::string>& original_lines, std::size_t wrap_width )
-{
-  std::vector<std::string> wrapped_lines;
-  for ( const auto& line : original_lines ) {
-    std::string current_line;
-    std::size_t vis_count = 0;
-    bool in_ansi = false;
-    for ( const char c : line ) {
-      if ( c == '\x1b' ) {
-        in_ansi = true;
-      }
-      if ( in_ansi ) {
-        current_line += c;
-        if ( c == 'm' ) {
-          in_ansi = false;
-        }
-      } else {
-        if ( vis_count >= wrap_width ) {
-          wrapped_lines.push_back( current_line + "\033[0m" );
-          current_line.clear();
-          vis_count = 0;
-        }
-        current_line += c;
-        vis_count++;
-      }
-    }
-    if ( !current_line.empty() || line.empty() ) {
-      wrapped_lines.push_back( current_line + "\033[0m" );
-    }
-  }
-  return wrapped_lines;
-}
-
 } // namespace
 
 std::string Browser::format_url( std::string input )
diff --git a/ricochet/src/core/form_handler.cc b/ricochet/src/core/form_handler.cc
new file mode 100644
index 0000000..2d018c9
--- /dev/null
+++ b/ricochet/src/core/form_handler.cc
@@ -0,0 +1,165 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/form_handler.hh"
+#include "ricochet/core/ui_input.hh"
+#include "ricochet/core/utils.hh"
+
+namespace ricochet::core {
+
+InputAction submit_form( const render::InputField& target_input,
+                         const std::vector<render::InputField>& inputs,
+                         const std::string& current_url,
+                         std::vector<HttpRequest>& history,
+                         std::size_t& history_idx )
+{
+  std::string body;
+  for ( const auto& in : inputs ) {
+    if ( in.action == target_input.action && !in.name.empty() && in.type != "submit" && in.type != "button" ) {
+      if ( ( in.type == "checkbox" || in.type == "radio" ) && !in.checked ) {
+        continue;
+      }
+      std::string encoded = in.value;
+      for ( char& ch : encoded ) {
+        if ( ch == ' ' ) {
+          ch = '+';
+        }
+      }
+      if ( !body.empty() ) {
+        body += "&";
+      }
+      body += in.name + "=" + encoded;
+    }
+  }
+  const std::string action
+    = target_input.action.empty() ? current_url : normalize_url( target_input.action, current_url );
+  HttpRequest next_req { .url = action, .method = "GET", .body = "" };
+  if ( target_input.method == "post" || target_input.method == "POST" ) {
+    next_req.method = "POST";
+    next_req.body = body;
+  } else {
+    const char sep = action.contains( '?' ) ? '&' : '?';
+    next_req.url += sep + body;
+  }
+  history.resize( history_idx + 1 );
+  history.push_back( next_req );
+  history_idx++;
+  return InputAction::Navigate;
+}
+
+void update_input_value( PageData& page_data, std::size_t index, const std::string& query )
+{
+  page_data.inputs[index - 1].value = query;
+  const std::string marker = "[I" + std::to_string( index ) + ":";
+  const std::string replacement = "[I" + std::to_string( index ) + ":" + query + "]";
+
+  auto update_lines = [&]( std::vector<std::string>& lines_arr ) {
+    for ( auto& line : lines_arr ) {
+      const std::size_t pos = line.find( marker );
+      if ( pos != std::string::npos ) {
+        const std::size_t end = line.find( ']', pos );
+        if ( end != std::string::npos ) {
+          line.replace( pos, end - pos + 1, replacement );
+        }
+      }
+    }
+  };
+  update_lines( page_data.lines );
+  update_lines( page_data.original_lines );
+}
+
+void update_single_line_ui( std::string& line, const std::string& marker, const render::InputField& in )
+{
+  const std::string checked_str = marker + ( in.type == "checkbox" ? "[X] " : "(X) " ) + in.value + "]";
+  const std::string unchecked_str = marker + ( in.type == "checkbox" ? "[ ] " : "( ) " ) + in.value + "]";
+
+  const std::string& target_str = in.checked ? checked_str : unchecked_str;
+  const std::string& old_str = in.checked ? unchecked_str : checked_str;
+
+  const std::size_t pos = line.find( old_str );
+  if ( pos != std::string::npos ) {
+    line.replace( pos, old_str.length(), target_str );
+  }
+}
+
+void update_toggle_ui( PageData& page_data )
+{
+  for ( std::size_t i = 0; i < page_data.inputs.size(); ++i ) {
+    const auto& in = page_data.inputs[i];
+    if ( in.type != "checkbox" && in.type != "radio" ) {
+      continue;
+    }
+    const std::string marker = "[I" + std::to_string( i + 1 ) + ":";
+    for ( auto& line : page_data.lines ) {
+      update_single_line_ui( line, marker, in );
+    }
+    for ( auto& line : page_data.original_lines ) {
+      update_single_line_ui( line, marker, in );
+    }
+  }
+}
+
+InputAction handle_form_input( const tui::Terminal& terminal,
+                               PageData& page_data,
+                               const std::string& current_url,
+                               std::vector<HttpRequest>& history,
+                               std::size_t& history_idx )
+{
+  const std::string num_input = get_terminal_input( terminal, "Select Input [#]:" );
+  if ( num_input.empty() ) {
+    return InputAction::None;
+  }
+  std::size_t index = 0;
+  try {
+    index = std::stoul( num_input );
+  } catch ( ... ) {
+    return InputAction::None;
+  }
+  if ( index == 0 || index > page_data.inputs.size() ) {
+    return InputAction::None;
+  }
+
+  auto& target_input = page_data.inputs[index - 1];
+  if ( target_input.type == "submit" || target_input.type == "button" ) {
+    return submit_form( target_input, page_data.inputs, current_url, history, history_idx );
+  }
+
+  if ( target_input.type == "checkbox" || target_input.type == "radio" ) {
+    if ( target_input.type == "radio" ) {
+      for ( auto& in : page_data.inputs ) {
+        if ( in.name == target_input.name && in.action == target_input.action ) {
+          in.checked = false;
+        }
+      }
+      target_input.checked = true;
+    } else {
+      target_input.checked = !target_input.checked;
+    }
+    update_toggle_ui( page_data );
+    return InputAction::None;
+  }
+
+  const std::string query = get_terminal_input( terminal, "Enter Text [I" + std::to_string( index ) + "]:" );
+  if ( query.empty() ) {
+    return InputAction::None;
+  }
+  update_input_value( page_data, index, query );
+  return InputAction::None;
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/core/link_hints.cc b/ricochet/src/core/link_hints.cc
new file mode 100644
index 0000000..77b91b8
--- /dev/null
+++ b/ricochet/src/core/link_hints.cc
@@ -0,0 +1,104 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/link_hints.hh"
+#include "ricochet/core/ui_view.hh"
+#include "ricochet/core/utils.hh"
+#include <iostream>
+
+namespace ricochet::core {
+
+std::string index_to_hint( std::size_t index )
+{
+  const std::string alphabet = "asdfghjklqwertyuiopzxcvbnm";
+  std::string hint;
+  hint += alphabet[( index / alphabet.length() ) % alphabet.length()];
+  hint += alphabet[index % alphabet.length()];
+  return hint;
+}
+
+void toggle_link_hints( PageData& page_data, bool show )
+{
+  const std::string hl_start = "\033[0;1;35;7m ";
+  const std::string hl_end = " \033[0m";
+
+  std::vector<std::string> formatted_hints;
+  formatted_hints.reserve( page_data.links.size() );
+  for ( std::size_t i = 0; i < page_data.links.size(); ++i ) {
+    std::string h = hl_start;
+    h += index_to_hint( i );
+    h += hl_end;
+    formatted_hints.push_back( std::move( h ) );
+  }
+
+  for ( auto& line : page_data.lines ) {
+    for ( std::size_t i = 0; i < page_data.links.size(); ++i ) {
+      const std::string marker = "{L:" + std::to_string( i + 1 ) + "}";
+      if ( show ) {
+        const std::size_t pos = line.find( marker );
+        if ( pos != std::string::npos ) {
+          line.replace( pos, marker.length(), formatted_hints[i] );
+        }
+      } else {
+        const std::size_t pos = line.find( formatted_hints[i] );
+        if ( pos != std::string::npos ) {
+          line.replace( pos, formatted_hints[i].length(), marker );
+        }
+      }
+    }
+  }
+}
+
+void handle_follow_link( const tui::Terminal& terminal,
+                         PageData& page_data,
+                         std::string& current_url,
+                         std::size_t& scroll_y, // NOLINT(bugprone-easily-swappable-parameters)
+                         bool& navigate )
+{
+  toggle_link_hints( page_data, true );
+
+  draw_view( terminal, page_data.lines, scroll_y, current_url, page_data.title );
+
+  auto [w, h] = terminal.get_size();
+  terminal.move_cursor( h, 1 );
+  std::cout << "\x1b[2K\033[1;35;7m Follow Hint (2 keys): \033[0m ";
+  std::cout.flush();
+
+  std::string input;
+  input += terminal.read_key();
+  std::cout << input[0];
+  std::cout.flush();
+  input += terminal.read_key();
+
+  // bool found = false;
+  for ( std::size_t i = 0; i < page_data.links.size(); ++i ) {
+    if ( index_to_hint( i ) == input ) {
+      std::string target = page_data.links[i];
+      target = normalize_url( target, current_url );
+      target = strip_ddg_tracker( target );
+      current_url = target;
+      navigate = true;
+      // found = true;
+      break;
+    }
+  }
+
+  toggle_link_hints( page_data, false );
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/core/local_data.cc b/ricochet/src/core/local_data.cc
new file mode 100644
index 0000000..9115844
--- /dev/null
+++ b/ricochet/src/core/local_data.cc
@@ -0,0 +1,171 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/local_data.hh"
+#include <cstdlib>
+#include <fstream>
+#include <sys/stat.h>
+#include <vector>
+
+namespace ricochet::core {
+
+std::string get_config_path( const std::string& filename )
+{
+  const char* home = std::getenv( "HOME" ); // NOLINT(concurrency-mt-unsafe)
+  const std::string dir = ( home != nullptr ) ? std::string( home ) + "/.ricochet" : ".ricochet";
+  static_cast<void>( mkdir( dir.c_str(), 0755 ) );
+  return dir + "/" + filename;
+}
+
+void save_bookmark( const std::string& title, // NOLINT(bugprone-easily-swappable-parameters)
+                    const std::string& url )
+{
+  if ( url == "ricochet://bookmarks" ) {
+    return;
+  }
+  std::ofstream file( get_config_path( "bookmarks.txt" ), std::ios::app );
+  if ( !file.is_open() ) {
+    return;
+  }
+
+  std::string safe_title = title;
+  if ( safe_title.empty() ) {
+    safe_title = url;
+  }
+  for ( char& c : safe_title ) {
+    if ( c == '\n' || c == '\r' || c == '\t' ) {
+      c = ' ';
+    }
+  }
+  file << url << '\t' << safe_title << '\n';
+}
+
+std::string generate_bookmarks_html()
+{
+  std::ifstream file( get_config_path( "bookmarks.txt" ) );
+  std::string html = "<html><head><title>My Bookmarks</title></head><body><h1>Saved Bookmarks</h1><ul>";
+  if ( !file.is_open() ) {
+    html += "<li>No bookmarks found. Press 'b' on any page to add one!</li>";
+  } else {
+    std::string line;
+    while ( std::getline( file, line ) ) {
+      const std::size_t tab_pos = line.find( '\t' );
+      if ( tab_pos != std::string::npos ) {
+        const std::string url = line.substr( 0, tab_pos );
+        const std::string title = line.substr( tab_pos + 1 );
+        html += "<li><a href=\"";
+        html += url;
+        html += "\">[Link] ";
+        html += title;
+        html += "</a></li>";
+      }
+    }
+  }
+  html += "</ul></body></html>";
+  return html;
+}
+
+void append_to_history( const std::string& url, // NOLINT(bugprone-easily-swappable-parameters)
+                        const std::string& title )
+{
+  if ( url.starts_with( "ricochet://" ) ) {
+    return;
+  }
+  std::ofstream file( get_config_path( "history.txt" ), std::ios::app );
+  if ( !file.is_open() ) {
+    return;
+  }
+
+  std::string safe_title = title;
+  if ( safe_title.empty() ) {
+    safe_title = url;
+  }
+  for ( char& c : safe_title ) {
+    if ( c == '\n' || c == '\r' || c == '\t' ) {
+      c = ' ';
+    }
+  }
+  file << url << '\t' << safe_title << '\n';
+}
+
+std::string generate_history_html()
+{
+  std::ifstream file( get_config_path( "history.txt" ) );
+  std::string html = "<html><head><title>History</title></head><body><h1>Browsing History</h1><ul>";
+  if ( !file.is_open() ) {
+    html += "<li>No history found. Start browsing!</li>";
+  } else {
+    std::vector<std::string> lines;
+    std::string line;
+    while ( std::getline( file, line ) ) {
+      lines.push_back( std::move( line ) );
+    }
+
+    std::size_t count = 0;
+    for ( auto it = lines.rbegin(); it != lines.rend() && count < 100; ++it, ++count ) {
+      const std::size_t tab_pos = it->find( '\t' );
+      if ( tab_pos != std::string::npos ) {
+        const std::string url = it->substr( 0, tab_pos );
+        const std::string title = it->substr( tab_pos + 1 );
+        html += "<li><a href=\"";
+        html += url;
+        html += "\">[Link] ";
+        html += title;
+        html += "</a></li>";
+      }
+    }
+  }
+  html += "</ul></body></html>";
+  return html;
+}
+
+std::string generate_help_html()
+{
+  return R"(<html>
+  <head><title>Ricochet Help Manual</title></head>
+  <body>
+    <h1>Ricochet User Manual</h1>
+    <h2>1. Navigation & Browsing</h2>
+    <ul>
+      <li><b>j / k</b> : Scroll down / up</li>
+      <li><b>H / L</b> : History backward / forward</li>
+      <li><b>/</b> : Open prompt to enter a new URL</li>
+    </ul>
+    <h2>2. Page Interaction</h2>
+    <ul>
+      <li><b>f</b> : Toggle Link Hints (type the two letters to follow a link instantly)</li>
+      <li><b>n</b> : Find in page (search for text)</li>
+      <li><b>N</b> : Jump to the next search match</li>
+      <li><b>i</b> : Enter form input mode (fill textboxes, click buttons, toggle checkboxes)</li>
+    </ul>
+    <h2>3. Bookmarks & History</h2>
+    <ul>
+      <li><b>b</b> : Bookmark the current page</li>
+      <li><b>B</b> : View all saved bookmarks</li>
+      <li><b>h</b> : View browsing history</li>
+    </ul>
+    <h2>4. System</h2>
+    <ul>
+      <li><b>?</b> : Show this help manual</li>
+      <li><b>q</b> : Quit Ricochet</li>
+    </ul>
+  </body>
+  </html>)";
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/core/page_loader.cc b/ricochet/src/core/page_loader.cc
new file mode 100644
index 0000000..b9a5da5
--- /dev/null
+++ b/ricochet/src/core/page_loader.cc
@@ -0,0 +1,78 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/page_loader.hh"
+#include "ricochet/core/local_data.hh"
+#include "ricochet/core/page_processor.hh"
+#include "ricochet/core/utils.hh"
+#include "ricochet/parser/html_lexer.hh"
+#include "ricochet/parser/tree_builder.hh"
+#include "ricochet/render/renderer.hh"
+
+namespace ricochet::core {
+
+PageData load_page( const HttpRequest& req )
+{
+  std::string html_body;
+  if ( req.url == "ricochet://bookmarks" ) {
+    html_body = generate_bookmarks_html();
+  } else if ( req.url == "ricochet://history" ) {
+    html_body = generate_history_html();
+  } else if ( req.url == "ricochet://help" ) {
+    html_body = generate_help_html();
+  } else {
+    const net::HttpClient client;
+    auto response_result = client.fetch( req.url, req.method, req.body );
+    if ( !response_result.has_value() ) {
+      return { .lines
+               = { "\033[1;31m[!] Failed to load:\033[0m " + req.url, "", "Reason: " + response_result.error() },
+               .links = {},
+               .inputs = {},
+               .title = "Error" };
+    }
+
+    const auto& resp = response_result.value();
+    std::string c_type = resp.content_type;
+    for ( char& c : c_type ) {
+      if ( c >= 'A' && c <= 'Z' ) {
+        c = static_cast<char>( c + 32 );
+      }
+    }
+
+    const bool is_text
+      = c_type.starts_with( "text/" ) || c_type.contains( "xml" ) || c_type.contains( "json" ) || c_type.empty();
+
+    if ( !is_text ) {
+      return process_binary_download( req, resp );
+    }
+    html_body = response_result.value().body;
+  }
+
+  const parser::HtmlLexer lexer;
+  const parser::TreeBuilder builder;
+  const render::Renderer renderer;
+
+  const auto dom_root = builder.build( lexer.tokenize( html_body ) );
+  const render::RenderResult result = renderer.render( dom_root );
+  const std::string title = extract_title( dom_root );
+
+  return {
+    .lines = split_into_lines( result.text ), .links = result.links, .inputs = result.inputs, .title = title };
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/core/page_processor.cc b/ricochet/src/core/page_processor.cc
new file mode 100644
index 0000000..00728a9
--- /dev/null
+++ b/ricochet/src/core/page_processor.cc
@@ -0,0 +1,97 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/page_processor.hh"
+#include <fstream>
+#include <ranges>
+#include <vector>
+
+namespace ricochet::core {
+
+std::string extract_title( const parser::DomNode& root_node )
+{
+  std::vector<const parser::DomNode*> stack;
+  stack.push_back( &root_node );
+
+  while ( !stack.empty() ) {
+    const parser::DomNode* current = stack.back();
+    stack.pop_back();
+
+    std::string base_tag = current->tag_name;
+    const std::size_t space_pos = base_tag.find( ' ' );
+    if ( space_pos != std::string::npos ) {
+      base_tag = base_tag.substr( 0, space_pos );
+    }
+
+    for ( char& c : base_tag ) {
+      if ( c >= 'A' && c <= 'Z' ) {
+        c = static_cast<char>( c + 32 );
+      }
+    }
+
+    if ( base_tag == "title" ) {
+      std::string full_title;
+      for ( const auto& child : current->children ) {
+        if ( child.tag_name.empty() ) {
+          full_title += child.text_content;
+        }
+      }
+      if ( !full_title.empty() ) {
+        return full_title;
+      }
+    }
+
+    for ( const auto& child : std::ranges::reverse_view( current->children ) ) {
+      stack.push_back( &child );
+    }
+  }
+  return "";
+}
+
+PageData process_binary_download( const HttpRequest& req, const net::HttpResponse& resp )
+{
+  std::string fname = "download.dat";
+  const std::size_t slash = req.url.rfind( '/' );
+  if ( slash != std::string::npos && slash + 1 < req.url.length() ) {
+    fname = req.url.substr( slash + 1 );
+    const std::size_t q_pos = fname.find( '?' );
+    if ( q_pos != std::string::npos ) {
+      fname = fname.substr( 0, q_pos );
+    }
+  }
+  if ( fname.empty() ) {
+    fname = "download.dat";
+  }
+
+  std::ofstream out( fname, std::ios::binary );
+  out.write( resp.body.data(), static_cast<std::streamsize>( resp.body.size() ) );
+  out.close();
+
+  return { .lines = { "\033[1;32m[ Download Complete ]\033[0m",
+                      "",
+                      "Saved File : " + fname,
+                      "File Type  : " + resp.content_type,
+                      "File Size  : " + std::to_string( resp.body.size() ) + " bytes",
+                      "",
+                      "Press 'H' to return to the previous page." },
+           .links = {},
+           .inputs = {},
+           .title = "Download Manager" };
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/core/search_handler.cc b/ricochet/src/core/search_handler.cc
new file mode 100644
index 0000000..cab9e9c
--- /dev/null
+++ b/ricochet/src/core/search_handler.cc
@@ -0,0 +1,81 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/search_handler.hh"
+
+namespace ricochet::core {
+
+void find_search_matches( PageData& page_data, const std::string& query )
+{
+  page_data.last_search = query;
+  page_data.match_lines.clear();
+  page_data.current_match_idx = 0;
+  for ( std::size_t i = 0; i < page_data.original_lines.size(); ++i ) {
+    if ( page_data.original_lines[i].find( query ) != std::string::npos ) {
+      page_data.match_lines.push_back( i );
+    }
+  }
+}
+
+void apply_search_highlight( PageData& page_data, const std::string& query )
+{
+  page_data.lines = page_data.original_lines;
+  if ( page_data.match_lines.empty() ) {
+    return;
+  }
+
+  const std::string hl_start = "\033[43;30m";
+  const std::string hl_end = "\033[0m";
+
+  for ( const auto match_idx : page_data.match_lines ) {
+    auto& line = page_data.lines[match_idx];
+    std::size_t pos = 0;
+    std::string replacement;
+    replacement.reserve( hl_start.length() + query.length() + hl_end.length() );
+    replacement += hl_start;
+    replacement += query;
+    replacement += hl_end;
+    while ( ( pos = line.find( query, pos ) ) != std::string::npos ) {
+      line.replace( pos, query.length(), replacement );
+      pos += hl_start.length() + query.length() + hl_end.length();
+    }
+  }
+}
+
+void execute_search( PageData& page_data, const std::string& query, std::size_t& scroll_y, bool next_match )
+{
+  if ( query.empty() ) {
+    return;
+  }
+
+  if ( !next_match || query != page_data.last_search ) {
+    find_search_matches( page_data, query );
+    apply_search_highlight( page_data, query );
+  } else if ( !page_data.match_lines.empty() ) {
+    page_data.current_match_idx = ( page_data.current_match_idx + 1 ) % page_data.match_lines.size();
+  }
+
+  if ( page_data.match_lines.empty() ) {
+    return;
+  }
+
+  const std::size_t target_line = page_data.match_lines[page_data.current_match_idx];
+  scroll_y = ( target_line > 5 ) ? ( target_line - 5 ) : 0;
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/core/ui_input.cc b/ricochet/src/core/ui_input.cc
new file mode 100644
index 0000000..0f57dd1
--- /dev/null
+++ b/ricochet/src/core/ui_input.cc
@@ -0,0 +1,94 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/ui_input.hh"
+#include "ricochet/core/browser.hh"
+#include <iostream>
+
+namespace ricochet::core {
+
+std::string get_url_input( const tui::Terminal& terminal )
+{
+  auto [width, height] = terminal.get_size();
+  terminal.move_cursor( height, 1 );
+  std::cout << "\x1b[2K\033[7m URL: \033[0m ";
+  std::cout.flush();
+
+  std::string input;
+  terminal.show_cursor( true );
+  while ( true ) {
+    const char ch = terminal.read_key();
+    if ( ch == '\r' || ch == '\n' ) {
+      break;
+    }
+    if ( ch == 27 ) {
+      input.clear();
+      break;
+    }
+    if ( ch == 127 || ch == 8 ) {
+      if ( !input.empty() ) {
+        input.pop_back();
+        std::cout << "\b \b";
+        std::cout.flush();
+      }
+    } else if ( std::isprint( static_cast<unsigned char>( ch ) ) ) {
+      input += ch;
+      std::cout << ch;
+      std::cout.flush();
+    }
+  }
+  terminal.show_cursor( false );
+
+  return Browser::format_url( std::move( input ) );
+}
+
+std::string get_terminal_input( const tui::Terminal& terminal, const std::string& prompt )
+{
+  auto [width, height] = terminal.get_size();
+  terminal.move_cursor( height, 1 );
+  std::cout << "\x1b[2K\033[7m " << prompt << " \033[0m ";
+  std::cout.flush();
+
+  std::string input;
+  terminal.show_cursor( true );
+  while ( true ) {
+    const char ch = terminal.read_key();
+    if ( ch == '\r' || ch == '\n' ) {
+      break;
+    }
+    if ( ch == 27 ) {
+      input.clear();
+      break;
+    }
+    if ( ch == 127 || ch == 8 ) {
+      if ( !input.empty() ) {
+        input.pop_back();
+        std::cout << "\b \b";
+        std::cout.flush();
+      }
+    } else if ( std::isprint( static_cast<unsigned char>( ch ) ) ) {
+      input += ch;
+      std::cout << ch;
+      std::cout.flush();
+    }
+  }
+  terminal.show_cursor( false );
+  return input;
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/core/ui_view.cc b/ricochet/src/core/ui_view.cc
new file mode 100644
index 0000000..5164fe0
--- /dev/null
+++ b/ricochet/src/core/ui_view.cc
@@ -0,0 +1,103 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/ui_view.hh"
+#include <iostream>
+
+namespace ricochet::core {
+
+std::string build_footer( std::string_view url, std::size_t width )
+{
+  const std::string_view keys
+    = " | [j/k]Scroll [n/N]Find [/]Nav [f]Hint [i]In [r]Ref [H/L]Back [h]Hist [b/B]Mark [?]Help [q]Quit ";
+  const std::string_view prefix = " URL: ";
+
+  std::string footer;
+  if ( width <= keys.length() + prefix.length() + 3 ) {
+    footer.reserve( prefix.length() + url.length() + keys.length() );
+    footer += prefix;
+    footer += url;
+    footer += keys;
+    if ( footer.length() > width && width > 3 ) {
+      footer.erase( width - 3 );
+      footer += "...";
+    }
+  } else {
+    const std::size_t max_url_len = width - keys.length() - prefix.length();
+    footer.reserve( width );
+    footer += prefix;
+    if ( url.length() > max_url_len ) {
+      footer += url.substr( 0, max_url_len - 3 );
+      footer += "...";
+    } else {
+      footer += url;
+    }
+    footer += keys;
+  }
+
+  if ( footer.length() < width ) {
+    footer.append( width - footer.length(), ' ' );
+  }
+  return footer;
+}
+
+void draw_view( const tui::Terminal& terminal,
+                const std::vector<std::string>& lines,
+                std::size_t scroll_y,
+                std::string_view url,    // NOLINT(bugprone-easily-swappable-parameters)
+                std::string_view title ) // NOLINT(bugprone-easily-swappable-parameters)
+{
+  terminal.clear_screen();
+  auto [width, height] = terminal.get_size();
+  const std::size_t usable_height = ( height > 2 ) ? ( height - 2 ) : 1;
+
+  std::string clean_title( title );
+  if ( clean_title.empty() ) {
+    const std::size_t start = url.find( "://" );
+    const std::size_t host_start = ( start == std::string::npos ) ? 0 : start + 3;
+    const std::size_t host_end = url.find( '/', host_start );
+    clean_title = std::string( url.substr( host_start, host_end - host_start ) );
+  }
+  for ( char& c : clean_title ) {
+    if ( c == '\n' || c == '\r' ) {
+      c = ' ';
+    }
+  }
+
+  std::string header = " PAGE: " + clean_title;
+  if ( header.size() < width ) {
+    header.append( width - header.size(), ' ' );
+  } else if ( header.size() > width && width > 3 ) {
+    header = header.substr( 0, width - 3 ) + "...";
+  }
+  std::cout << "\033[7m" << header << "\033[0m\r\n";
+
+  for ( std::size_t i = 0; i < usable_height; ++i ) {
+    if ( scroll_y + i < lines.size() ) {
+      std::cout << lines[scroll_y + i] << "\r\n";
+    } else {
+      std::cout << "~\r\n";
+    }
+  }
+
+  const std::string footer = build_footer( url, width );
+  std::cout << "\033[7m" << footer << "\033[0m";
+  std::cout.flush();
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/core/utils.cc b/ricochet/src/core/utils.cc
new file mode 100644
index 0000000..ddc6321
--- /dev/null
+++ b/ricochet/src/core/utils.cc
@@ -0,0 +1,118 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/core/utils.hh"
+
+namespace ricochet::core {
+
+std::vector<std::string> split_into_lines( const std::string& text )
+{
+  std::vector<std::string> lines;
+  std::size_t start = 0;
+  while ( start < text.length() ) {
+    const std::size_t end = text.find( '\n', start );
+    if ( end == std::string::npos ) {
+      lines.push_back( text.substr( start ) );
+      break;
+    }
+    lines.push_back( text.substr( start, end - start ) );
+    start = end + 1;
+  }
+  return lines;
+}
+
+std::string normalize_url( const std::string& target, const std::string& current_url )
+{
+  if ( target.starts_with( "/" ) ) {
+    if ( target.starts_with( "//" ) ) {
+      return "https:" + target;
+    }
+    const std::size_t slash_pos = current_url.find( '/', 8 );
+    const std::string domain
+      = ( slash_pos == std::string::npos ) ? current_url : current_url.substr( 0, slash_pos );
+    return domain + target;
+  }
+  if ( !target.starts_with( "http" ) ) {
+    const std::size_t last_slash = current_url.rfind( '/' );
+    if ( last_slash > 7 ) {
+      return current_url.substr( 0, last_slash + 1 ) + target;
+    }
+    return current_url + "/" + target;
+  }
+  return target;
+}
+
+std::string strip_ddg_tracker( std::string target )
+{
+  const std::size_t uddg_pos = target.find( "uddg=" );
+  if ( uddg_pos != std::string::npos ) {
+    const std::size_t end_pos = target.find( '&', uddg_pos );
+    const std::string encoded = target.substr( uddg_pos + 5, end_pos - ( uddg_pos + 5 ) );
+    std::string decoded;
+    for ( std::size_t i = 0; i < encoded.length(); ++i ) {
+      if ( encoded[i] == '%' && i + 2 < encoded.length() ) {
+        const std::string hex = encoded.substr( i + 1, 2 );
+        try {
+          decoded += static_cast<char>( std::stoi( hex, nullptr, 16 ) );
+        } catch ( const std::exception& ) {
+          (void)0;
+        }
+        i += 2;
+      } else {
+        decoded += encoded[i];
+      }
+    }
+    return decoded;
+  }
+  return target;
+}
+
+std::vector<std::string> wrap_lines( const std::vector<std::string>& original_lines, std::size_t wrap_width )
+{
+  std::vector<std::string> wrapped_lines;
+  for ( const auto& line : original_lines ) {
+    std::string current_line;
+    std::size_t vis_count = 0;
+    bool in_ansi = false;
+    for ( const char c : line ) {
+      if ( c == '\x1b' ) {
+        in_ansi = true;
+      }
+      if ( in_ansi ) {
+        current_line += c;
+        if ( c == 'm' ) {
+          in_ansi = false;
+        }
+      } else {
+        if ( vis_count >= wrap_width ) {
+          wrapped_lines.push_back( current_line + "\033[0m" );
+          current_line.clear();
+          vis_count = 0;
+        }
+        current_line += c;
+        vis_count++;
+      }
+    }
+    if ( !current_line.empty() || line.empty() ) {
+      wrapped_lines.push_back( current_line + "\033[0m" );
+    }
+  }
+  return wrapped_lines;
+}
+
+} // namespace ricochet::core
diff --git a/ricochet/src/net/config.cc b/ricochet/src/net/config.cc
new file mode 100644
index 0000000..6f257df
--- /dev/null
+++ b/ricochet/src/net/config.cc
@@ -0,0 +1,64 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/net/config.hh"
+
+#include <cstdlib>
+#include <fstream>
+#include <sys/stat.h>
+
+namespace ricochet::net {
+
+std::string get_config_path( const std::string& filename )
+{
+  const char* home = std::getenv( "HOME" ); // NOLINT(concurrency-mt-unsafe)
+  const std::string dir = ( home != nullptr ) ? std::string( home ) + "/.ricochet" : ".ricochet";
+  static_cast<void>( mkdir( dir.c_str(), 0755 ) );
+  return dir + "/" + filename;
+}
+
+BrowserConfig& get_browser_config()
+{
+  static BrowserConfig config { .user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+                                              "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+                                .homepage = "https://wikipedia.org" };
+  static bool loaded = false;
+  if ( !loaded ) {
+    std::ifstream file( get_config_path( "config.txt" ) );
+    if ( file.is_open() ) {
+      std::string line;
+      while ( std::getline( file, line ) ) {
+        const std::size_t eq = line.find( '=' );
+        if ( eq == std::string::npos ) {
+          continue;
+        }
+        const std::string key = line.substr( 0, eq );
+        const std::string val = line.substr( eq + 1 );
+        if ( key == "user_agent" ) {
+          config.user_agent = val;
+        } else if ( key == "homepage" ) {
+          config.homepage = val;
+        }
+      }
+    }
+    loaded = true;
+  }
+  return config;
+}
+
+} // namespace ricochet::net
diff --git a/ricochet/src/net/cookie_jar.cc b/ricochet/src/net/cookie_jar.cc
new file mode 100644
index 0000000..1328511
--- /dev/null
+++ b/ricochet/src/net/cookie_jar.cc
@@ -0,0 +1,124 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/net/cookie_jar.hh"
+#include "ricochet/net/config.hh"
+
+#include <fstream>
+
+namespace ricochet::net {
+
+void load_cookies_from_file( CookieJar& jar )
+{
+  std::ifstream file( get_config_path( "cookies.txt" ) );
+  if ( !file.is_open() ) {
+    return;
+  }
+
+  std::string line;
+  while ( std::getline( file, line ) ) {
+    const std::size_t t1 = line.find( '\t' );
+    if ( t1 == std::string::npos ) {
+      continue;
+    }
+    const std::size_t t2 = line.find( '\t', t1 + 1 );
+    if ( t2 != std::string::npos ) {
+      jar[line.substr( 0, t1 )][line.substr( t1 + 1, t2 - t1 - 1 )] = line.substr( t2 + 1 );
+    }
+  }
+}
+
+CookieJar& get_cookie_jar()
+{
+  static CookieJar jar;
+  static bool initialized = false;
+  if ( !initialized ) {
+    load_cookies_from_file( jar );
+    initialized = true;
+  }
+  return jar;
+}
+
+void save_cookies_to_file( const CookieJar& jar )
+{
+  std::ofstream file( get_config_path( "cookies.txt" ), std::ios::trunc );
+  if ( !file.is_open() ) {
+    return;
+  }
+
+  for ( const auto& [domain, cookies] : jar ) {
+    for ( const auto& [k, v] : cookies ) {
+      file << domain << '\t' << k << '\t' << v << '\n';
+    }
+  }
+}
+
+void update_cookies( const std::string& raw_response, // NOLINT(bugprone-easily-swappable-parameters)
+                     const std::string& host )
+{
+  std::size_t pos = 0;
+  bool updated = false;
+  while ( ( pos = raw_response.find( "Set-Cookie: ", pos ) ) != std::string::npos ) {
+    pos += 12;
+    const std::size_t end_pos = raw_response.find( '\r', pos );
+    if ( end_pos == std::string::npos ) {
+      break;
+    }
+
+    const std::string cookie_line = raw_response.substr( pos, end_pos - pos );
+    const std::size_t semi_pos = cookie_line.find( ';' );
+    const std::string cookie_pair
+      = ( semi_pos == std::string::npos ) ? cookie_line : cookie_line.substr( 0, semi_pos );
+
+    const std::size_t eq_pos = cookie_pair.find( '=' );
+    if ( eq_pos != std::string::npos ) {
+      const std::string key = cookie_pair.substr( 0, eq_pos );
+      const std::string val = cookie_pair.substr( eq_pos + 1 );
+      get_cookie_jar()[host][key] = val;
+      updated = true;
+    }
+  }
+  if ( updated ) {
+    save_cookies_to_file( get_cookie_jar() );
+  }
+}
+
+std::string build_cookie_header( const std::string& host )
+{
+  const auto& jar = get_cookie_jar();
+  auto it = jar.find( host );
+  if ( it == jar.end() || it->second.empty() ) {
+    return "";
+  }
+
+  std::string header = "Cookie: ";
+  bool first = true;
+  for ( const auto& [k, v] : it->second ) {
+    if ( !first ) {
+      header += "; ";
+    }
+    header += k;
+    header += "=";
+    header += v;
+    first = false;
+  }
+  header += "\r\n";
+  return header;
+}
+
+} // namespace ricochet::net
diff --git a/ricochet/src/net/http_client.cc b/ricochet/src/net/http_client.cc
index 5f5b449..4a10c02 100644
--- a/ricochet/src/net/http_client.cc
+++ b/ricochet/src/net/http_client.cc
@@ -17,302 +17,30 @@
  */
 
 #include "ricochet/net/http_client.hh"
-#include "ricochet/net/ssl_socket.hh"
 
+#include "ricochet/net/config.hh"
+#include "ricochet/net/cookie_jar.hh"
+#include "ricochet/net/http_utils.hh"
+#include "ricochet/net/ssl_socket.hh"
 #include "ricochet/net/sys/address.hh"
 #include "ricochet/net/sys/socket.hh"
+#include "ricochet/net/url_parser.hh"
 
 #include <cstddef>
-#include <cstdlib>
 #include <format>
-#include <fstream>
 #include <string>
 #include <string_view>
-#include <sys/stat.h>
-#include <unordered_map>
 
 namespace ricochet::net {
 
 namespace {
 
-struct ParsedUrl
-{
-  std::string host {};
-  std::string path {};
-};
-
-std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
-{
-  std::string_view prefix = "http://";
-  if ( url.starts_with( "https://" ) ) {
-    prefix = "https://";
-  } else if ( url.starts_with( "http://" ) ) {
-    prefix = "http://";
-  } else {
-    return std::unexpected( "Only 'http://' or 'https://' URLs are supported." );
-  }
-
-  url.remove_prefix( prefix.length() );
-
-  const auto sep_pos = url.find_first_of( "/?#" );
-
-  ParsedUrl result;
-  if ( sep_pos == std::string_view::npos ) {
-    result.host = std::string( url );
-    result.path = "/";
-  } else {
-    result.host = std::string( url.substr( 0, sep_pos ) );
-    result.path = std::string( url.substr( sep_pos ) );
-    if ( result.path[0] != '/' ) {
-      result.path.insert( 0, "/" );
-    }
-  }
-  return result;
-}
-
-std::string dechunk( std::string_view body ) // NOLINT(readability-convert-member-functions-to-static)
-{
-  std::string result;
-  std::size_t pos = 0;
-  while ( pos < body.size() ) {
-    // find hex length end with \r\n
-    auto line_end = body.find( "\r\n", pos );
-    if ( line_end == std::string_view::npos ) {
-      break;
-    }
-
-    // parse hex length
-    const std::string len_str( body.substr( pos, line_end - pos ) );
-    unsigned int chunk_size = 0;
-    try {
-      chunk_size = std::stoul( len_str, nullptr, 16 );
-    } catch ( ... ) {
-      break;
-    }
-
-    if ( chunk_size == 0 ) {
-      break; // end of stream
-    }
-
-    // extract data block (skip \r\n)
-    pos = line_end + 2;
-    if ( pos + chunk_size > body.size() ) {
-      break;
-    }
-    result.append( body.substr( pos, chunk_size ) );
-
-    // skip data block's \r\n
-    pos += chunk_size + 2;
-  }
-  return result;
-}
-
-std::string remove_html_comments( std::string html ) // NOLINT(readability-convert-member-functions-to-static)
-{
-  std::size_t start_pos = 0;
-  while ( ( start_pos = html.find( "<!--", start_pos ) ) != std::string::npos ) {
-    auto end_pos = html.find( "-->", start_pos );
-    if ( end_pos != std::string::npos ) {
-      html.erase( start_pos, end_pos - start_pos + 3 );
-    } else {
-      html.erase( start_pos );
-      break;
-    }
-  }
-  return html;
-}
-
-std::string remove_tag_blocks( std::string html, const std::string& tag_name ) // NOLINT
-{
-  const std::string open_tag = "<" + tag_name;
-  const std::string close_tag = "</" + tag_name + ">";
-  std::size_t start_pos = 0;
-
-  while ( ( start_pos = html.find( open_tag, start_pos ) ) != std::string::npos ) {
-    const std::size_t end_pos = html.find( close_tag, start_pos );
-    if ( end_pos != std::string::npos ) {
-      html.erase( start_pos, end_pos - start_pos + close_tag.length() );
-    } else {
-      html.erase( start_pos );
-      break;
-    }
-  }
-  return html;
-}
-
-std::string extract_redirect_url( const std::string& raw_response, bool is_https, const std::string& host )
-{
-  auto loc_pos = raw_response.find( "Location: " );
-  if ( loc_pos == std::string::npos ) {
-    loc_pos = raw_response.find( "location: " );
-  }
-  if ( loc_pos != std::string::npos ) {
-    loc_pos += 10;
-    auto end_pos = raw_response.find( '\r', loc_pos );
-    if ( end_pos == std::string::npos ) {
-      end_pos = raw_response.find( '\n', loc_pos );
-    }
-    if ( end_pos != std::string::npos ) {
-      std::string next_url = raw_response.substr( loc_pos, end_pos - loc_pos );
-      while ( !next_url.empty() && std::isspace( static_cast<unsigned char>( next_url.front() ) ) ) {
-        next_url.erase( 0, 1 );
-      }
-      if ( next_url.starts_with( "/" ) ) {
-        next_url = ( is_https ? "https://" : "http://" ) + host + next_url;
-      }
-      return next_url;
-    }
-  }
-  return "";
-}
-
-std::string get_config_path( const std::string& filename )
-{
-  const char* home = std::getenv( "HOME" ); // NOLINT(concurrency-mt-unsafe)
-  const std::string dir = ( home != nullptr ) ? std::string( home ) + "/.ricochet" : ".ricochet";
-  static_cast<void>( mkdir( dir.c_str(), 0755 ) );
-  return dir + "/" + filename;
-}
-
-struct BrowserConfig
-{
-  std::string user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
-                           "Chrome/124.0.0.0 Safari/537.36";
-  std::string homepage = "https://wikipedia.org";
-};
-
-BrowserConfig& get_browser_config()
-{
-  static BrowserConfig config;
-  static bool loaded = false;
-  if ( !loaded ) {
-    std::ifstream file( get_config_path( "config.txt" ) );
-    if ( file.is_open() ) {
-      std::string line;
-      while ( std::getline( file, line ) ) {
-        const std::size_t eq = line.find( '=' );
-        if ( eq == std::string::npos ) {
-          continue;
-        }
-        const std::string key = line.substr( 0, eq );
-        const std::string val = line.substr( eq + 1 );
-        if ( key == "user_agent" ) {
-          config.user_agent = val;
-        } else if ( key == "homepage" ) {
-          config.homepage = val;
-        }
-      }
-    }
-    loaded = true;
-  }
-  return config;
-}
-
-using CookieJar = std::unordered_map<std::string, std::unordered_map<std::string, std::string>>;
-
-void load_cookies_from_file( CookieJar& jar )
-{
-  std::ifstream file( get_config_path( "cookies.txt" ) );
-  if ( !file.is_open() ) {
-    return;
-  }
-
-  std::string line;
-  while ( std::getline( file, line ) ) {
-    const std::size_t t1 = line.find( '\t' );
-    if ( t1 == std::string::npos ) {
-      continue;
-    }
-    const std::size_t t2 = line.find( '\t', t1 + 1 );
-    if ( t2 != std::string::npos ) {
-      jar[line.substr( 0, t1 )][line.substr( t1 + 1, t2 - t1 - 1 )] = line.substr( t2 + 1 );
-    }
-  }
-}
-
-CookieJar& get_cookie_jar()
-{
-  static CookieJar jar;
-  static bool initialized = false;
-  if ( !initialized ) {
-    load_cookies_from_file( jar );
-    initialized = true;
-  }
-  return jar;
-}
-
-void save_cookies_to_file( const CookieJar& jar )
-{
-  std::ofstream file( get_config_path( "cookies.txt" ), std::ios::trunc );
-  if ( !file.is_open() ) {
-    return;
-  }
-
-  for ( const auto& [domain, cookies] : jar ) {
-    for ( const auto& [k, v] : cookies ) {
-      file << domain << '\t' << k << '\t' << v << '\n';
-    }
-  }
-}
-
-void update_cookies( const std::string& raw_response, // NOLINT(bugprone-easily-swappable-parameters)
-                     const std::string& host )
-{
-  std::size_t pos = 0;
-  bool updated = false;
-  while ( ( pos = raw_response.find( "Set-Cookie: ", pos ) ) != std::string::npos ) {
-    pos += 12;
-    const std::size_t end_pos = raw_response.find( '\r', pos );
-    if ( end_pos == std::string::npos ) {
-      break;
-    }
-
-    const std::string cookie_line = raw_response.substr( pos, end_pos - pos );
-    const std::size_t semi_pos = cookie_line.find( ';' );
-    const std::string cookie_pair
-      = ( semi_pos == std::string::npos ) ? cookie_line : cookie_line.substr( 0, semi_pos );
-
-    const std::size_t eq_pos = cookie_pair.find( '=' );
-    if ( eq_pos != std::string::npos ) {
-      const std::string key = cookie_pair.substr( 0, eq_pos );
-      const std::string val = cookie_pair.substr( eq_pos + 1 );
-      get_cookie_jar()[host][key] = val;
-      updated = true;
-    }
-  }
-  if ( updated ) {
-    save_cookies_to_file( get_cookie_jar() );
-  }
-}
-
-std::string build_cookie_header( const std::string& host )
-{
-  const auto& jar = get_cookie_jar();
-  auto it = jar.find( host );
-  if ( it == jar.end() || it->second.empty() ) {
-    return "";
-  }
-
-  std::string header = "Cookie: ";
-  bool first = true;
-  for ( const auto& [k, v] : it->second ) {
-    if ( !first ) {
-      header += "; ";
-    }
-    header += k;
-    header += "=";
-    header += v;
-    first = false;
-  }
-  header += "\r\n";
-  return header;
-}
-
 struct FetchResult
 {
   std::string raw_response {};
   std::string error {};
 };
+
 FetchResult do_network_request( const std::string& host,
                                 const std::string& service, // NOLINT(bugprone-easily-swappable-parameters)
                                 const std::string& path,    // NOLINT(bugprone-easily-swappable-parameters)
@@ -373,11 +101,67 @@ FetchResult do_network_request( const std::string& host,
   return res;
 }
 
+void parse_response_headers( const std::string& raw_response, // NOLINT(bugprone-easily-swappable-parameters)
+                             const std::string& host,         // NOLINT(bugprone-easily-swappable-parameters)
+                             HttpResponse& response,
+                             std::string& headers )
+{
+  const auto header_end = raw_response.find( "\r\n\r\n" );
+  headers = ( header_end != std::string::npos ) ? raw_response.substr( 0, header_end ) : raw_response;
+  update_cookies( headers, host );
+
+  if ( header_end != std::string::npos ) {
+    response.body = raw_response.substr( header_end + 4 );
+    std::size_t ct_pos = headers.find( "Content-Type: " );
+    if ( ct_pos == std::string::npos ) {
+      ct_pos = headers.find( "content-type: " );
+    }
+    if ( ct_pos != std::string::npos ) {
+      ct_pos += 14;
+      const std::size_t end_pos = headers.find( '\r', ct_pos );
+      if ( end_pos != std::string::npos ) {
+        response.content_type = headers.substr( ct_pos, end_pos - ct_pos );
+      }
+    }
+    if ( raw_response.size() >= 12 ) {
+      try {
+        response.status_code = std::stoi( raw_response.substr( 9, 3 ) );
+      } catch ( ... ) {
+        response.status_code = 0;
+      }
+    }
+  } else {
+    response.body = raw_response;
+    response.status_code = 0;
+  }
+}
+
+void sanitize_response_body( HttpResponse& response, const std::string& raw_response )
+{
+  if ( raw_response.contains( "Transfer-Encoding: chunked" ) ) {
+    response.body = dechunk( response.body );
+  }
+  std::string ct_lower = response.content_type;
+  for ( char& c : ct_lower ) {
+    if ( c >= 'A' && c <= 'Z' ) {
+      c = static_cast<char>( c + 32 );
+    }
+  }
+
+  if ( ct_lower.starts_with( "text/" ) || ct_lower.contains( "xml" ) ) {
+    response.body = remove_html_comments( response.body );
+    response.body = remove_tag_blocks( response.body, "script" );
+    response.body = remove_tag_blocks( response.body, "style" );
+  }
+}
+
 } // namespace
 
-std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url, // NOLINT
-                                                            std::string_view method,
-                                                            std::string_view body ) const
+std::expected<HttpResponse, std::string>
+HttpClient::fetch(              // NOLINT(readability-convert-member-functions-to-static)
+  std::string_view url,         // NOLINT(bugprone-easily-swappable-parameters)
+  std::string_view method,      // NOLINT(bugprone-easily-swappable-parameters)
+  std::string_view body ) const // NOLINT(bugprone-easily-swappable-parameters)
 {
   std::string current_url( url );
   std::string current_method( method );
@@ -403,35 +187,8 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
     const std::string& raw_response = net_res.raw_response;
 
     HttpResponse response;
-    const auto header_end = raw_response.find( "\r\n\r\n" );
-    const std::string headers
-      = ( header_end != std::string::npos ) ? raw_response.substr( 0, header_end ) : raw_response;
-    update_cookies( headers, host );
-
-    if ( header_end != std::string::npos ) {
-      response.body = raw_response.substr( header_end + 4 );
-      std::size_t ct_pos = headers.find( "Content-Type: " );
-      if ( ct_pos == std::string::npos ) {
-        ct_pos = headers.find( "content-type: " );
-      }
-      if ( ct_pos != std::string::npos ) {
-        ct_pos += 14;
-        const std::size_t end_pos = headers.find( '\r', ct_pos );
-        if ( end_pos != std::string::npos ) {
-          response.content_type = headers.substr( ct_pos, end_pos - ct_pos );
-        }
-      }
-      if ( raw_response.size() >= 12 ) {
-        try {
-          response.status_code = std::stoi( raw_response.substr( 9, 3 ) );
-        } catch ( ... ) {
-          response.status_code = 0;
-        }
-      }
-    } else {
-      response.body = raw_response;
-      response.status_code = 0;
-    }
+    std::string headers;
+    parse_response_headers( raw_response, host, response, headers );
 
     if ( response.status_code >= 300 && response.status_code < 400 ) {
       const std::string next_url = extract_redirect_url( headers, is_https, host );
@@ -445,21 +202,7 @@ std::expected<HttpResponse, std::string> HttpClient::fetch( std::string_view url
       }
     }
 
-    if ( raw_response.contains( "Transfer-Encoding: chunked" ) ) {
-      response.body = dechunk( response.body );
-    }
-    std::string ct_lower = response.content_type;
-    for ( char& c : ct_lower ) {
-      if ( c >= 'A' && c <= 'Z' ) {
-        c = static_cast<char>( c + 32 );
-      }
-    }
-
-    if ( ct_lower.starts_with( "text/" ) || ct_lower.contains( "xml" ) ) {
-      response.body = remove_html_comments( response.body );
-      response.body = remove_tag_blocks( response.body, "script" );
-      response.body = remove_tag_blocks( response.body, "style" );
-    }
+    sanitize_response_body( response, raw_response );
     return response;
   }
 
diff --git a/ricochet/src/net/http_utils.cc b/ricochet/src/net/http_utils.cc
new file mode 100644
index 0000000..98f6dae
--- /dev/null
+++ b/ricochet/src/net/http_utils.cc
@@ -0,0 +1,93 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/net/http_utils.hh"
+
+#include <string>
+#include <string_view>
+
+namespace ricochet::net {
+
+std::string dechunk( std::string_view body )
+{
+  std::string result;
+  std::size_t pos = 0;
+  while ( pos < body.size() ) {
+    auto line_end = body.find( "\r\n", pos );
+    if ( line_end == std::string_view::npos ) {
+      break;
+    }
+
+    const std::string len_str( body.substr( pos, line_end - pos ) );
+    unsigned int chunk_size = 0;
+    try {
+      chunk_size = std::stoul( len_str, nullptr, 16 );
+    } catch ( ... ) {
+      break;
+    }
+
+    if ( chunk_size == 0 ) {
+      break;
+    }
+
+    pos = line_end + 2;
+    if ( pos + chunk_size > body.size() ) {
+      break;
+    }
+    result.append( body.substr( pos, chunk_size ) );
+
+    pos += chunk_size + 2;
+  }
+  return result;
+}
+
+std::string remove_html_comments( std::string html )
+{
+  std::size_t start_pos = 0;
+  while ( ( start_pos = html.find( "<!--", start_pos ) ) != std::string::npos ) {
+    auto end_pos = html.find( "-->", start_pos );
+    if ( end_pos != std::string::npos ) {
+      html.erase( start_pos, end_pos - start_pos + 3 );
+    } else {
+      html.erase( start_pos );
+      break;
+    }
+  }
+  return html;
+}
+
+std::string remove_tag_blocks( std::string html, // NOLINT(bugprone-easily-swappable-parameters)
+                               const std::string& tag_name )
+{
+  const std::string open_tag = "<" + tag_name;
+  const std::string close_tag = "</" + tag_name + ">";
+  std::size_t start_pos = 0;
+
+  while ( ( start_pos = html.find( open_tag, start_pos ) ) != std::string::npos ) {
+    const std::size_t end_pos = html.find( close_tag, start_pos );
+    if ( end_pos != std::string::npos ) {
+      html.erase( start_pos, end_pos - start_pos + close_tag.length() );
+    } else {
+      html.erase( start_pos );
+      break;
+    }
+  }
+  return html;
+}
+
+} // namespace ricochet::net
diff --git a/ricochet/src/net/url_parser.cc b/ricochet/src/net/url_parser.cc
new file mode 100644
index 0000000..95e86ef
--- /dev/null
+++ b/ricochet/src/net/url_parser.cc
@@ -0,0 +1,87 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/net/url_parser.hh"
+
+#include <cctype>
+
+namespace ricochet::net {
+
+std::expected<ParsedUrl, std::string> parse_url( std::string_view url )
+{
+  std::string_view prefix = "http://";
+  if ( url.starts_with( "https://" ) ) {
+    prefix = "https://";
+  } else if ( url.starts_with( "http://" ) ) {
+    prefix = "http://";
+  } else {
+    return std::unexpected( "Only 'http://' or 'https://' URLs are supported." );
+  }
+
+  url.remove_prefix( prefix.length() );
+
+  const auto sep_pos = url.find_first_of( "/?#" );
+
+  ParsedUrl result;
+  if ( sep_pos == std::string_view::npos ) {
+    result.host = std::string( url );
+    result.path = "/";
+  } else {
+    result.host = std::string( url.substr( 0, sep_pos ) );
+    std::string_view path_view = url.substr( sep_pos );
+    const auto hash_pos = path_view.find( '#' );
+    if ( hash_pos != std::string_view::npos ) {
+      path_view = path_view.substr( 0, hash_pos );
+    }
+    result.path = std::string( path_view );
+    if ( result.path.empty() || result.path[0] != '/' ) {
+      result.path.insert( 0, "/" );
+    }
+  }
+  return result;
+}
+
+std::string extract_redirect_url( const std::string& raw_response, bool is_https, const std::string& host )
+{
+  auto loc_pos = raw_response.find( "Location: " );
+  if ( loc_pos == std::string::npos ) {
+    loc_pos = raw_response.find( "location: " );
+  }
+  if ( loc_pos != std::string::npos ) {
+    loc_pos += 10;
+    auto end_pos = raw_response.find( '\r', loc_pos );
+    if ( end_pos == std::string::npos ) {
+      end_pos = raw_response.find( '\n', loc_pos );
+    }
+    if ( end_pos != std::string::npos ) {
+      std::string next_url = raw_response.substr( loc_pos, end_pos - loc_pos );
+      while ( !next_url.empty() && std::isspace( static_cast<unsigned char>( next_url.front() ) ) ) {
+        next_url.erase( 0, 1 );
+      }
+      if ( next_url.starts_with( "//" ) ) {
+        next_url = ( is_https ? "https:" : "http:" ) + next_url;
+      } else if ( next_url.starts_with( "/" ) ) {
+        next_url = ( is_https ? "https://" : "http://" ) + host + next_url;
+      }
+      return next_url;
+    }
+  }
+  return "";
+}
+
+} // namespace ricochet::net
diff --git a/ricochet/src/render/input_renderer.cc b/ricochet/src/render/input_renderer.cc
new file mode 100644
index 0000000..076fa2a
--- /dev/null
+++ b/ricochet/src/render/input_renderer.cc
@@ -0,0 +1,82 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/render/input_renderer.hh"
+#include "ricochet/render/internal.hh"
+#include "ricochet/render/utils.hh"
+
+namespace ricochet::render {
+
+namespace {
+
+std::string build_input_hint( const std::string& tag_name, bool checked )
+{
+  std::string placeholder = extract_attr( tag_name, "placeholder" );
+  const std::string type = extract_attr( tag_name, "type" );
+  std::string val = extract_attr( tag_name, "value" );
+
+  if ( !placeholder.empty() ) {
+    return placeholder;
+  }
+  if ( type == "submit" || type == "button" ) {
+    return val.empty() ? "Submit" : val;
+  }
+  if ( type == "checkbox" ) {
+    return checked ? "[X] " + val : "[ ] " + val;
+  }
+  if ( type == "radio" ) {
+    return checked ? "(X) " + val : "( ) " + val;
+  }
+  if ( type == "hidden" ) {
+    return "hidden";
+  }
+  if ( !val.empty() ) {
+    return val;
+  }
+  return "text";
+}
+
+} // namespace
+
+void render_input_node( const parser::DomNode& node,
+                        RenderResult& result,
+                        const FormContext& ctx,
+                        std::string& output )
+{
+  std::string type = extract_attr( node.tag_name, "type" );
+  const std::size_t space_pos = node.tag_name.find( ' ' );
+  const std::string base_tag
+    = ( space_pos == std::string::npos ) ? node.tag_name : node.tag_name.substr( 0, space_pos );
+  if ( base_tag == "button" && type.empty() ) {
+    type = "submit";
+  }
+  const std::string default_val = extract_attr( node.tag_name, "value" );
+  const bool is_checked = node.tag_name.contains( "checked" );
+  result.inputs.push_back(
+    { extract_attr( node.tag_name, "name" ), ctx.action, ctx.method, default_val, type, is_checked } );
+
+  std::string hint = build_input_hint( node.tag_name, is_checked );
+  if ( base_tag == "button" ) {
+    hint = "Submit";
+  }
+  if ( hint != "hidden" ) {
+    output += " \033[7;33m[I" + std::to_string( result.inputs.size() ) + ":" + hint + "]\033[0m ";
+  }
+}
+
+} // namespace ricochet::render
diff --git a/ricochet/src/render/renderer.cc b/ricochet/src/render/renderer.cc
index 53eca1b..7fb665f 100644
--- a/ricochet/src/render/renderer.cc
+++ b/ricochet/src/render/renderer.cc
@@ -17,92 +17,15 @@
  */
 
 #include "ricochet/render/renderer.hh"
-#include <algorithm>
-#include <array>
-#include <cstdint>
-#include <stdexcept>
+#include "ricochet/render/input_renderer.hh"
+#include "ricochet/render/internal.hh"
+#include "ricochet/render/table_renderer.hh"
+#include "ricochet/render/utils.hh"
 
 namespace ricochet::render {
 
 namespace {
 
-std::string decode_entities( std::string text )
-{
-  constexpr std::array<std::pair<std::string_view, std::string_view>, 25> entities
-    = { { { "&nbsp;", " " },   { "&lt;", "<" },     { "&gt;", ">" },     { "&amp;", "&" },   { "&quot;", "\"" },
-          { "&apos;", "'" },   { "&copy;", "©" },   { "&reg;", "®" },    { "&trade;", "™" }, { "&euro;", "€" },
-          { "&pound;", "£" },  { "&yen;", "¥" },    { "&cent;", "¢" },   { "&sect;", "§" },  { "&para;", "¶" },
-          { "&hellip;", "…" }, { "&dagger;", "†" }, { "&Dagger;", "‡" }, { "&bull;", "•" },  { "&prime;", "′" },
-          { "&Prime;", "″" },  { "&lsaquo;", "‹" }, { "&rsaquo;", "›" }, { "&oline;", "‾" }, { "&frasl;", "⁄" } } };
-
-  for ( const auto& [entity, replacement] : entities ) {
-    std::size_t pos = 0;
-    while ( ( pos = text.find( entity, pos ) ) != std::string::npos ) {
-      text.replace( pos, entity.length(), replacement );
-      pos += replacement.length();
-    }
-  }
-
-  std::size_t pos = 0;
-  while ( ( pos = text.find( "&#", pos ) ) != std::string::npos ) {
-    const std::size_t end = text.find( ';', pos );
-    if ( end != std::string::npos && end - pos < 10 ) {
-      const std::string code = text.substr( pos + 2, end - pos - 2 );
-      try {
-        std::uint32_t cp = 0;
-        if ( !code.empty() && ( code[0] == 'x' || code[0] == 'X' ) ) {
-          cp = std::stoul( code.substr( 1 ), nullptr, 16 );
-        } else {
-          cp = std::stoul( code );
-        }
-        if ( cp < 128 ) {
-          text.replace( pos, end - pos + 1, 1, static_cast<char>( cp ) );
-          continue;
-        }
-      } catch ( const std::invalid_argument& ) {
-        (void)0; // Not a valid number, leave as-is
-      } catch ( const std::out_of_range& ) {
-        (void)0; // Value too large, leave as-is
-      }
-    }
-    pos++;
-  }
-  return text;
-}
-
-std::string extract_attr( const std::string& tag_name, std::string_view attr_name )
-{
-  std::string match = " " + std::string( attr_name ) + "=";
-  std::size_t pos = tag_name.find( match );
-
-  if ( pos == std::string::npos ) {
-    match = std::string( attr_name ) + "=";
-    if ( !tag_name.starts_with( match ) ) {
-      return "";
-    }
-    pos = 0;
-  } else {
-    pos += 1;
-  }
-
-  pos += attr_name.length() + 1;
-  if ( pos >= tag_name.length() ) {
-    return "";
-  }
-
-  const char quote = tag_name[pos];
-  if ( quote == '"' || quote == '\'' ) {
-    const std::size_t end = tag_name.find( quote, pos + 1 );
-    if ( end != std::string::npos ) {
-      return tag_name.substr( pos + 1, end - pos - 1 );
-    }
-    return "";
-  }
-
-  const std::size_t end = tag_name.find_first_of( " >/", pos );
-  return tag_name.substr( pos, ( end == std::string::npos ) ? std::string::npos : end - pos );
-}
-
 void render_link_end( const parser::DomNode& node, RenderResult& result )
 {
   result.text += "\033[0m";
@@ -125,221 +48,9 @@ void render_img( const parser::DomNode& node, RenderResult& result )
   }
 }
 
-std::string build_input_hint( const std::string& tag_name, bool checked )
-{
-  std::string placeholder = extract_attr( tag_name, "placeholder" );
-  const std::string type = extract_attr( tag_name, "type" );
-  std::string val = extract_attr( tag_name, "value" );
-
-  if ( !placeholder.empty() ) {
-    return placeholder;
-  }
-  if ( type == "submit" || type == "button" ) {
-    return val.empty() ? "Submit" : val;
-  }
-  if ( type == "checkbox" ) {
-    return checked ? "[X] " + val : "[ ] " + val;
-  }
-  if ( type == "radio" ) {
-    return checked ? "(X) " + val : "( ) " + val;
-  }
-  if ( type == "hidden" ) {
-    return "hidden";
-  }
-  if ( !val.empty() ) {
-    return val;
-  }
-  return "text";
-}
-
-struct FormContext
-{
-  std::string action;
-  std::string method;
-};
-
-bool is_ignored_tag( std::string_view tag )
-{
-  return tag == "head" || tag == "style" || tag == "script" || tag == "meta" || tag == "title" || tag == "link";
-}
-
-bool is_heading_tag( std::string_view tag )
-{
-  return tag == "h1" || tag == "h2" || tag == "h3" || tag == "h4";
-}
-
-void render_input_node( const parser::DomNode& node,
-                        RenderResult& result,
-                        const FormContext& ctx,
-                        std::string& output )
-{
-  std::string type = extract_attr( node.tag_name, "type" );
-  const std::size_t space_pos = node.tag_name.find( ' ' );
-  const std::string base_tag
-    = ( space_pos == std::string::npos ) ? node.tag_name : node.tag_name.substr( 0, space_pos );
-  if ( base_tag == "button" && type.empty() ) {
-    type = "submit";
-  }
-  const std::string default_val = extract_attr( node.tag_name, "value" );
-  const bool is_checked = node.tag_name.contains( "checked" );
-  result.inputs.push_back(
-    { extract_attr( node.tag_name, "name" ), ctx.action, ctx.method, default_val, type, is_checked } );
-
-  std::string hint = build_input_hint( node.tag_name, is_checked );
-  if ( base_tag == "button" ) {
-    hint = "Submit";
-  }
-  if ( hint != "hidden" ) {
-    output += " \033[7;33m[I" + std::to_string( result.inputs.size() ) + ":" + hint + "]\033[0m ";
-  }
-}
-
-void render_node( const parser::DomNode& node, RenderResult& result, FormContext ctx );
-
-std::size_t get_visible_length( std::string_view str )
-{
-  std::size_t len = 0;
-  bool in_ansi = false;
-  for ( std::size_t i = 0; i < str.length(); ++i ) {
-    const auto c = static_cast<unsigned char>( str[i] );
-    if ( c == 0x1B ) {
-      in_ansi = true;
-    } else if ( in_ansi && c == 'm' ) {
-      in_ansi = false;
-    } else if ( !in_ansi ) {
-      if ( ( c & 0x80 ) == 0 || ( c & 0xE0 ) == 0xC0 ) {
-        len += 1;
-      } // ASCII (width 1) Latin/Greek (width 1)
-      else if ( ( c & 0xF0 ) == 0xE0 || ( c & 0xF8 ) == 0xF0 ) {
-        len += 2;
-      } // CJK (width 2) Emoji/Rare (width 2)
-    }
-  }
-  return len;
-}
-
-std::size_t get_node_text_len( const parser::DomNode& node ) // NOLINT(misc-no-recursion)
-{
-  std::size_t len = get_visible_length( decode_entities( node.text_content ) );
-  for ( const auto& child : node.children ) {
-    len += get_node_text_len( child );
-  }
-  return len;
-}
-
-void process_table_row_widths( const parser::DomNode& row, std::vector<std::size_t>& widths )
-{
-  std::size_t col_idx = 0;
-  for ( const auto& cell : row.children ) {
-    const std::size_t space_pos = cell.tag_name.find( ' ' );
-    const std::string tag
-      = ( space_pos == std::string::npos ) ? cell.tag_name : cell.tag_name.substr( 0, space_pos );
-    if ( tag == "td" || tag == "th" ) {
-      const std::size_t len = get_node_text_len( cell ) + 2;
-      if ( col_idx >= widths.size() ) {
-        widths.push_back( len );
-      } else if ( len > widths[col_idx] ) {
-        widths[col_idx] = len;
-      }
-      col_idx++;
-    }
-  }
-}
-
-std::vector<std::size_t> calc_table_widths( const parser::DomNode& table_node )
-{
-  std::vector<std::size_t> widths;
-  for ( const auto& child : table_node.children ) {
-    const std::size_t space_pos = child.tag_name.find( ' ' );
-    const std::string tag
-      = ( space_pos == std::string::npos ) ? child.tag_name : child.tag_name.substr( 0, space_pos );
-    if ( tag == "tr" ) {
-      process_table_row_widths( child, widths );
-    } else if ( tag == "tbody" || tag == "thead" ) {
-      for ( const auto& row : child.children ) {
-        if ( row.tag_name.starts_with( "tr" ) ) {
-          process_table_row_widths( row, widths );
-        }
-      }
-    }
-  }
-  for ( auto& w : widths ) {
-    w = std::min<std::size_t>( w, 30 );
-  }
-  return widths;
-}
-
-void render_table_row( const parser::DomNode& row, // NOLINT(misc-no-recursion)
-                       RenderResult& result,
-                       const FormContext& ctx,
-                       const std::vector<std::size_t>& widths )
-{
-  std::string& output = result.text;
-  output += "\033[90m|\033[0m ";
-  std::size_t col_idx = 0;
-  for ( const auto& cell : row.children ) {
-    const std::size_t cell_space = cell.tag_name.find( ' ' );
-    const std::string c_tag
-      = ( cell_space == std::string::npos ) ? cell.tag_name : cell.tag_name.substr( 0, cell_space );
-    if ( c_tag != "td" && c_tag != "th" ) {
-      continue;
-    }
-
-    const std::size_t text_start = output.size();
-    if ( c_tag == "th" ) {
-      output += "\033[1;36m";
-    }
-
-    for ( const auto& cell_child : cell.children ) {
-      render_node( cell_child, result, ctx );
-    }
-
-    if ( c_tag == "th" ) {
-      output += "\033[0m";
-    }
-
-    const std::string added = output.substr( text_start );
-    const std::size_t vis_len = get_visible_length( added );
-    const std::size_t tw = ( col_idx < widths.size() ) ? widths[col_idx] : 10;
-
-    if ( vis_len < tw ) {
-      output.append( tw - vis_len, ' ' );
-    }
-    output += " \033[90m|\033[0m ";
-    col_idx++;
-  }
-  output += "\n";
-}
-
-void render_table( const parser::DomNode& node, // NOLINT(misc-no-recursion)
-                   RenderResult& result,
-                   const FormContext& ctx )
-{
-  std::string& output = result.text;
-  const std::vector<std::size_t> widths = calc_table_widths( node );
-
-  output += "\n\033[90m+" + std::string( 78, '-' ) + "+\033[0m\n";
-
-  for ( const auto& child : node.children ) {
-    const std::size_t child_space = child.tag_name.find( ' ' );
-    const std::string child_tag
-      = ( child_space == std::string::npos ) ? child.tag_name : child.tag_name.substr( 0, child_space );
-    if ( child_tag == "tr" ) {
-      render_table_row( child, result, ctx, widths );
-    } else if ( child_tag == "tbody" || child_tag == "thead" ) {
-      for ( const auto& row : child.children ) {
-        if ( row.tag_name.starts_with( "tr" ) ) {
-          render_table_row( row, result, ctx, widths );
-        }
-      }
-    }
-  }
-  output += "\033[90m+" + std::string( 78, '-' ) + "+\033[0m\n";
-}
+} // namespace
 
-void render_node( const parser::DomNode& node, // NOLINT(misc-no-recursion)
-                  RenderResult& result,
-                  FormContext ctx )
+void render_node( const parser::DomNode& node, RenderResult& result, FormContext ctx ) // NOLINT(misc-no-recursion)
 {
   std::string& output = result.text;
   const std::size_t space_pos = node.tag_name.find( ' ' );
@@ -401,8 +112,6 @@ void render_node( const parser::DomNode& node, // NOLINT(misc-no-recursion)
   }
 }
 
-} // namespace
-
 RenderResult Renderer::render( // NOLINT(readability-convert-member-functions-to-static)
   const parser::DomNode& node ) const
 {
diff --git a/ricochet/src/render/table_renderer.cc b/ricochet/src/render/table_renderer.cc
new file mode 100644
index 0000000..37e6bfb
--- /dev/null
+++ b/ricochet/src/render/table_renderer.cc
@@ -0,0 +1,147 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/render/table_renderer.hh"
+#include "ricochet/render/internal.hh"
+#include "ricochet/render/utils.hh"
+#include <algorithm>
+
+namespace ricochet::render {
+
+namespace {
+
+std::size_t get_node_text_len( const parser::DomNode& node ) // NOLINT(misc-no-recursion)
+{
+  std::size_t len = get_visible_length( decode_entities( node.text_content ) );
+  for ( const auto& child : node.children ) {
+    len += get_node_text_len( child );
+  }
+  return len;
+}
+
+void process_table_row_widths( const parser::DomNode& row, std::vector<std::size_t>& widths )
+{
+  std::size_t col_idx = 0;
+  for ( const auto& cell : row.children ) {
+    const std::size_t space_pos = cell.tag_name.find( ' ' );
+    const std::string tag
+      = ( space_pos == std::string::npos ) ? cell.tag_name : cell.tag_name.substr( 0, space_pos );
+    if ( tag == "td" || tag == "th" ) {
+      const std::size_t len = get_node_text_len( cell ) + 2;
+      if ( col_idx >= widths.size() ) {
+        widths.push_back( len );
+      } else if ( len > widths[col_idx] ) {
+        widths[col_idx] = len;
+      }
+      col_idx++;
+    }
+  }
+}
+
+std::vector<std::size_t> calc_table_widths( const parser::DomNode& table_node )
+{
+  std::vector<std::size_t> widths;
+  for ( const auto& child : table_node.children ) {
+    const std::size_t space_pos = child.tag_name.find( ' ' );
+    const std::string tag
+      = ( space_pos == std::string::npos ) ? child.tag_name : child.tag_name.substr( 0, space_pos );
+    if ( tag == "tr" ) {
+      process_table_row_widths( child, widths );
+    } else if ( tag == "tbody" || tag == "thead" ) {
+      for ( const auto& row : child.children ) {
+        if ( row.tag_name.starts_with( "tr" ) ) {
+          process_table_row_widths( row, widths );
+        }
+      }
+    }
+  }
+  for ( auto& w : widths ) {
+    w = std::min<std::size_t>( w, 30 );
+  }
+  return widths;
+}
+
+void render_table_row( const parser::DomNode& row,
+                       RenderResult& result,
+                       const FormContext& ctx,
+                       const std::vector<std::size_t>& widths )
+{
+  std::string& output = result.text;
+  output += "\033[90m|\033[0m ";
+  std::size_t col_idx = 0;
+  for ( const auto& cell : row.children ) {
+    const std::size_t cell_space = cell.tag_name.find( ' ' );
+    const std::string c_tag
+      = ( cell_space == std::string::npos ) ? cell.tag_name : cell.tag_name.substr( 0, cell_space );
+    if ( c_tag != "td" && c_tag != "th" ) {
+      continue;
+    }
+
+    const std::size_t text_start = output.size();
+    if ( c_tag == "th" ) {
+      output += "\033[1;36m";
+    }
+
+    for ( const auto& cell_child : cell.children ) {
+      render_node( cell_child, result, ctx );
+    }
+
+    if ( c_tag == "th" ) {
+      output += "\033[0m";
+    }
+
+    const std::string added = output.substr( text_start );
+    const std::size_t vis_len = get_visible_length( added );
+    const std::size_t tw = ( col_idx < widths.size() ) ? widths[col_idx] : 10;
+
+    if ( vis_len < tw ) {
+      output.append( tw - vis_len, ' ' );
+    }
+    output += " \033[90m|\033[0m ";
+    col_idx++;
+  }
+  output += "\n";
+}
+
+} // namespace
+
+void render_table( const parser::DomNode& node, RenderResult& result, const FormContext& ctx )
+{
+  std::string& output = result.text;
+  const std::vector<std::size_t> widths = calc_table_widths( node );
+
+  output += "\n\033[90m+" + std::string( 78, '-' ) + "+\033[0m\n";
+
+  for ( const auto& child : node.children ) {
+    const std::size_t child_space = child.tag_name.find( ' ' );
+    const std::string child_tag
+      = ( child_space == std::string::npos ) ? child.tag_name : child.tag_name.substr( 0, child_space );
+    if ( child_tag == "tr" ) {
+      render_table_row( child, result, ctx, widths );
+    } else if ( child_tag == "tbody" || child_tag == "thead" ) {
+      for ( const auto& row : child.children ) {
+        if ( row.tag_name.starts_with( "tr" ) ) {
+          render_table_row( row, result, ctx, widths );
+        }
+      }
+    }
+  }
+  output += "\033[90m+" + std::string( 78, '-' ) + "+\033[0m\n";
+}
+
+} // namespace ricochet::render
diff --git a/ricochet/src/render/utils.cc b/ricochet/src/render/utils.cc
new file mode 100644
index 0000000..9c6610a
--- /dev/null
+++ b/ricochet/src/render/utils.cc
@@ -0,0 +1,135 @@
+/*
+ * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation.
+ * Copyright (C) 2026  Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ricochet/render/utils.hh"
+
+#include <array>
+#include <cstdint>
+#include <stdexcept>
+
+namespace ricochet::render {
+
+std::string decode_entities( std::string text )
+{
+  constexpr std::array<std::pair<std::string_view, std::string_view>, 25> entities
+    = { { { "&nbsp;", " " },   { "&lt;", "<" },     { "&gt;", ">" },     { "&amp;", "&" },   { "&quot;", "\"" },
+          { "&apos;", "'" },   { "&copy;", "©" },   { "&reg;", "®" },    { "&trade;", "™" }, { "&euro;", "€" },
+          { "&pound;", "£" },  { "&yen;", "¥" },    { "&cent;", "¢" },   { "&sect;", "§" },  { "&para;", "¶" },
+          { "&hellip;", "…" }, { "&dagger;", "†" }, { "&Dagger;", "‡" }, { "&bull;", "•" },  { "&prime;", "′" },
+          { "&Prime;", "″" },  { "&lsaquo;", "‹" }, { "&rsaquo;", "›" }, { "&oline;", "‾" }, { "&frasl;", "⁄" } } };
+
+  for ( const auto& [entity, replacement] : entities ) {
+    std::size_t pos = 0;
+    while ( ( pos = text.find( entity, pos ) ) != std::string::npos ) {
+      text.replace( pos, entity.length(), replacement );
+      pos += replacement.length();
+    }
+  }
+
+  std::size_t pos = 0;
+  while ( ( pos = text.find( "&#", pos ) ) != std::string::npos ) {
+    const std::size_t end = text.find( ';', pos );
+    if ( end != std::string::npos && end - pos < 10 ) {
+      const std::string code = text.substr( pos + 2, end - pos - 2 );
+      try {
+        std::uint32_t cp = 0;
+        if ( !code.empty() && ( code[0] == 'x' || code[0] == 'X' ) ) {
+          cp = std::stoul( code.substr( 1 ), nullptr, 16 );
+        } else {
+          cp = std::stoul( code );
+        }
+        if ( cp < 128 ) {
+          text.replace( pos, end - pos + 1, 1, static_cast<char>( cp ) );
+          continue;
+        }
+      } catch ( const std::invalid_argument& ) {
+        (void)0;
+      } catch ( const std::out_of_range& ) {
+        (void)0;
+      }
+    }
+    pos++;
+  }
+  return text;
+}
+
+std::string extract_attr( const std::string& tag_name, std::string_view attr_name )
+{
+  std::string match = " " + std::string( attr_name ) + "=";
+  std::size_t pos = tag_name.find( match );
+
+  if ( pos == std::string::npos ) {
+    match = std::string( attr_name ) + "=";
+    if ( !tag_name.starts_with( match ) ) {
+      return "";
+    }
+    pos = 0;
+  } else {
+    pos += 1;
+  }
+
+  pos += attr_name.length() + 1;
+  if ( pos >= tag_name.length() ) {
+    return "";
+  }
+
+  const char quote = tag_name[pos];
+  if ( quote == '"' || quote == '\'' ) {
+    const std::size_t end = tag_name.find( quote, pos + 1 );
+    if ( end != std::string::npos ) {
+      return tag_name.substr( pos + 1, end - pos - 1 );
+    }
+    return "";
+  }
+
+  const std::size_t end = tag_name.find_first_of( " >/", pos );
+  return tag_name.substr( pos, ( end == std::string::npos ) ? std::string::npos : end - pos );
+}
+
+std::size_t get_visible_length( std::string_view str )
+{
+  std::size_t len = 0;
+  bool in_ansi = false;
+  for ( std::size_t i = 0; i < str.length(); ++i ) {
+    const auto c = static_cast<unsigned char>( str[i] );
+    if ( c == 0x1B ) {
+      in_ansi = true;
+    } else if ( in_ansi && c == 'm' ) {
+      in_ansi = false;
+    } else if ( !in_ansi ) {
+      if ( ( c & 0x80 ) == 0 || ( c & 0xE0 ) == 0xC0 ) {
+        len += 1;
+      } else if ( ( c & 0xF0 ) == 0xE0 || ( c & 0xF8 ) == 0xF0 ) {
+        len += 2;
+      }
+    }
+  }
+  return len;
+}
+
+bool is_ignored_tag( std::string_view tag )
+{
+  return tag == "head" || tag == "style" || tag == "script" || tag == "meta" || tag == "title" || tag == "link";
+}
+
+bool is_heading_tag( std::string_view tag )
+{
+  return tag == "h1" || tag == "h2" || tag == "h3" || tag == "h4";
+}
+
+} // namespace ricochet::render
-- 
cgit v1.2.3