diff --git a/source/articles/example-CSS-selectors-easy-way.md b/source/articles/example-CSS-selectors-easy-way.md
index f9a3239..08a2e68 100644
--- a/source/articles/example-CSS-selectors-easy-way.md
+++ b/source/articles/example-CSS-selectors-easy-way.md
@@ -1,5 +1,7 @@
 # Examples: CSS selectors, the easy way
 
+For the full CSS and Selectors API reference, see the [CSS module](../modules/css.md) and [Selectors module](../modules/selectors.md) documentation.
+
 Let's start with an easy example of using `lexbor` for parsing and serializing
 CSS selectors. This example breaks down the major steps and elements, explaining
 the overall purpose, requirements, and assumptions at each step.
@@ -30,7 +32,7 @@ real-world example will be provided later.
 The code includes the necessary header files and defines a callback function
 (`callback`) that prints the parsed data.
 
-```c
+```C
 #include <lexbor/css/css.h>
 
 lxb_status_t callback(const lxb_char_t *data, size_t len, void *ctx)
@@ -45,7 +47,7 @@ lxb_status_t callback(const lxb_char_t *data, size_t len, void *ctx)
 The `main` function initializes the CSS parser, parses a CSS selector string,
 and then serializes the resulting selector list.
 
-```c
+```C
 int main(int argc, const char *argv[])
 {
     // ... (variable declarations)
@@ -81,7 +83,7 @@ int main(int argc, const char *argv[])
 The code defines a CSS selector string (`slctrs`) and initializes the CSS
 parser.
 
-```c
+```C
 static const lxb_char_t slctrs[] = ":has(div, :not(as, 1%, .class), #hash)";
 
 parser = lxb_css_parser_create();
@@ -94,7 +96,7 @@ status = lxb_css_parser_init(parser, NULL);
 The code parses the CSS selector string, checks for parsing errors, and prints
 the result.
 
-```c
+```C
 list = lxb_css_selectors_parse(parser, slctrs,
                                sizeof(slctrs) / sizeof(lxb_char_t) - 1);
 
@@ -109,7 +111,7 @@ if (parser->status != LXB_STATUS_OK) {
 
 The example serializes the parsed selector list and prints any parser logs.
 
-```c
+```C
 printf("Result: ");
 (void) lxb_css_selector_serialize_list(list, callback, NULL);
 printf("\n");
@@ -118,7 +120,7 @@ printf("\n");
 if (lxb_css_log_length(lxb_css_parser_log(parser)) != 0) {
     printf("Log:\n");
     // Serialize parser logs with proper indentation.
-    (void) lxb_css_log_serialize(parser->log, callback, NULL,
+    (void) lxb_css_log_serialize(lxb_css_parser_log(parser), callback, NULL,
                                  indent, indent_length);
     printf("\n");
 }
@@ -130,7 +132,7 @@ if (lxb_css_log_length(lxb_css_parser_log(parser)) != 0) {
 Finally, the code destroys resources for the parser and frees memory allocated
 for the selector list.
 
-```c
+```C
 (void) lxb_css_parser_destroy(parser, true);
 lxb_css_selector_list_destroy_memory(list);
 ```
diff --git a/source/articles/part-1-html.md b/source/articles/part-1-html.md
index 3dc9506..b1c3ae3 100644
--- a/source/articles/part-1-html.md
+++ b/source/articles/part-1-html.md
@@ -1,5 +1,7 @@
 # Part one: HTML
 
+**Note:** This article was written during the early development of the Lexbor HTML parser. Some code examples and internal values (such as token type flags) may differ from the current implementation. For up-to-date API reference, see the [HTML module documentation](../modules/html.md).
+
 Hello, everyone!
 
 In this article, I will explain how to create a superfast HTML parser that
@@ -61,6 +63,8 @@ windows-874, windows-1250, windows-1251, windows-1252, windows-1254,
 windows-1255, windows-1256, windows-1257, windows-1258, gb18030, Big5,
 ISO-2022-JP, Shift_JIS, EUC-KR, UTF-16BE, UTF-16LE, and x-user-defined.
 
+For details on Lexbor's encoding support, see the [Encoding module documentation](../modules/encoding.md).
+
 ## Preprocessing
 
 Once we have decoded the bytes into Unicode characters, we need to perform a
@@ -446,7 +450,7 @@ be the corresponding ID from the enumeration.
 
 Example:
 
-```c
+```C
 typedef enum {
     LXB_TAG__UNDEF       = 0x0000,
     LXB_TAG__END_OF_FILE = 0x0001,
@@ -469,7 +473,7 @@ the DOM (Document Object Model) will include a `Tag ID`. This approach avoids
 the need for two comparisons: one for the node type and one for the element.
 Instead, a single check can be performed:
 
-```c
+```C
 if (node->tag_id == LXB_TAG_DIV) {
     /* Optimal code */
 }
@@ -477,7 +481,7 @@ if (node->tag_id == LXB_TAG_DIV) {
 
 Alternatively, you could use:
 
-```c
+```C
 if (node->type == LXB_DOM_NODE_TYPE_ELEMENT && node->tag_id == LXB_TAG_DIV) {
     /* Oh my code */
 }
@@ -534,7 +538,7 @@ tree. This is achieved using the Flags bitmap field.
 
 The field can contain the following values:
 
-```c
+```C
 enum {
     LXB_HTML_TOKEN_TYPE_OPEN         = 0x0000,
     LXB_HTML_TOKEN_TYPE_CLOSE        = 0x0001,
@@ -548,6 +552,9 @@ enum {
     LXB_HTML_TOKEN_TYPE_DONE         = 0x0100
 };
 ```
+
+**Note:** This enum reflects an earlier version of the codebase. In the current implementation (see `source/lexbor/html/token.h`), the `TEXT`, `DATA`, `RCDATA`, `CDATA`, and `NULL` token types have been removed, and the remaining values have been renumbered.
+
 Besides the opening/closing token type, there are additional values for the data
 converter. Only the tokenizer knows how to correctly convert data, and it marks
 the token to indicate how the data should be processed.
@@ -675,7 +682,7 @@ tree_build_in_body_character(token) {
 ```
 
 In Lexbor HTML:
-```c
+```C
 tree_build_in_body_character(token) {
     lexbor_str_t str = {0};
     lxb_html_parser_char_t pc = {0};
@@ -698,7 +705,7 @@ As illustrated by the example, we have removed all character-based conditions
 and created a common function for text processing. This function takes an
 argument with data transformation settings:
 
-```c
+```C
 pc.replace_null /* Replace each '\0' with REPLACEMENT CHARACTER (U+FFFD) */
 pc.drop_null    /* Delete all '\0's */
 pc.is_attribute /* If data is an attribute value, we need smarter parsing */
diff --git a/source/articles/part-2-css.md b/source/articles/part-2-css.md
index 4ab8a03..b27e86b 100644
--- a/source/articles/part-2-css.md
+++ b/source/articles/part-2-css.md
@@ -1,5 +1,7 @@
 # Part Two: CSS
 
+**Note:** This article was written during the early development of the Lexbor CSS parser. Some internal details may differ from the current implementation. For up-to-date API reference, see the [CSS module documentation](../modules/css.md). For current project status, see the [Roadmap](../roadmap.md).
+
 Hello, everyone!
 
 We continue our series on developing a browser engine. Better late than never!
@@ -90,7 +92,7 @@ div {width: 10px !important}
 ```
 
 The tokenizer generates tokens:
-```html
+```
 "div"       — <ident-token>
 " "         — <whitespace-token>
 "{"         — <left-curly-bracket-token>
@@ -180,7 +182,7 @@ to these callbacks. It would look something like this:
 div {width: 10px !important}
 ```
 
-```html
+```
 "div"       — callback_qualified_rule_prelude(<ident-token>)
 " "         — callback_qualified_rule_prelude(<whitespace-token>)
             — callback_qualified_rule_prelude(<end-token>)
@@ -230,7 +232,7 @@ It might look something like this:
 div {width: 10px !important}
 ```
 
-```html
+```
 "div {"                    — Selectors parse
 "width: 10px !important}"  — Declarations parse
 ```
@@ -353,6 +355,8 @@ like `Qualified Rule`, `At-Rule`, etc., as well as different system phases.
 There is also a stack due to the recursive nature of CSS structures, which
 avoids recursion directly.
 
+**Note:** The `LXB_CSS_SYNTAX_TOKEN__TERMINATED` token and the `lxb_css_syntax_parser_token()` function described above reflect the internal parsing architecture. For the public API, see the [CSS module documentation](../modules/css.md).
+
 **Pros:**
 1. Complete control over the tokenizer.
 2. Speed, as everything happens on the fly.
@@ -372,7 +376,7 @@ is structured. Values in grammars can include combinators and multipliers.
 
 **Sequential Order**
 
-```html
+```
 <my> = a b c
 ```
 
@@ -380,7 +384,7 @@ is structured. Values in grammars can include combinators and multipliers.
 - `<my> = a b c`
 
 **One Value from the List**:
-```html
+```
 <my> = a | b | c
 ```
 
@@ -390,7 +394,7 @@ is structured. Values in grammars can include combinators and multipliers.
 - `<my> = c`
 
 **One or All Values from the List in Any Order**:
-```html
+```
 <my> = a || b || c
 ```
 
@@ -435,7 +439,7 @@ For those familiar with regular expressions, this concept will be immediately
 clear.
 
 **Zero or Infinite Number of Times**:
-```html
+```
 <my> = a*
 ```
 
@@ -445,7 +449,7 @@ clear.
 - `<my> = `
 
 **One or Infinite Number of Times**:
-```html
+```
 <my> = a+
 ```
 
@@ -454,7 +458,7 @@ clear.
 - `<my> = a a a a a a a a a a a a a`
 
 **May or May Not be Present**:
-```html
+```
 <my> = a?
 ```
 
@@ -463,7 +467,7 @@ clear.
 - `<my> = `
 
 **May be Present from `A` to `B` Times, Period**:
-```html
+```
 <my> = a{1,4}
 ```
 
@@ -474,7 +478,7 @@ clear.
 - `<my> = a a a a`
 
 **One or Infinite Number of Times Separated by Comma**:
-```html
+```
 <my> = a#
 ```
 
@@ -485,7 +489,7 @@ clear.
 - `<my> = a, a, a, a`
 
 **Exactly One Value Must be Present**:
-```html
+```
 <my> = [a? | b? | c?]!
 ```
 
@@ -495,7 +499,7 @@ error.
 
 **Multipliers can be Combined**:
 
-```html
+```
 <my> = a#{1,5}
 ```
 
@@ -545,7 +549,7 @@ The main problems I encountered:
 
 For example, consider this grammar:
 
-```html
+```
 <text-decoration-line> = none | [ underline || overline || line-through || blink ]
 <text-decoration-style> = solid | double | dotted | dashed | wavy
 <text-decoration-color> = <color>
@@ -561,7 +565,7 @@ To manage this, I implemented a limiter for group options using `/1`. This
 notation indicates how many options should be selected from the group. As a
 result, `<text-decoration>` was transformed into:
 
-```html
+```
 <text-decoration> = <text-decoration-line> || <text-decoration-style> || <text-decoration-color>/1
 ```
 
@@ -572,7 +576,7 @@ spaces between them. This approach is insufficient; we need to address this
 directly in the grammar. To handle this, the `^WS` modifier (Without Spaces) was
 introduced:
 
-```html
+```
 <frequency> = <number-token> <frequency-units>^WS
 <
 
@@ -595,7 +599,7 @@ For example:
 
 Tests would be generated as follows:
 
-```html
+```
 <x> = a b c
 <x> = a c b
 <x> = b a c
diff --git a/source/documentation.md b/source/documentation.md
index 6b59baf..5bcfe8a 100644
--- a/source/documentation.md
+++ b/source/documentation.md
@@ -7,7 +7,7 @@ These steps show how to use `lexbor` in your code. They assume you are using Lin
 2. Let's parse some sample HTML markup.
    Save the following code as `myhtml.c`:
 
-   ```c
+   ```C
    #include <lexbor/html/parser.h>
    #include <lexbor/dom/interfaces/element.h>
 
@@ -82,7 +82,7 @@ Optional flags recognized by the `cmake` command:
 | LEXBOR_BUILD_SEPARATELY        |  OFF    | Build all modules separately. Each module will have its own library (shared and static).                  |
 | LEXBOR_BUILD_EXAMPLES          |  OFF    | Build example programs.                                                                                   |
 | LEXBOR_BUILD_TESTS             |  OFF    | Build tests.                                                                                              |
-| LEXBOR_BUILD_TESTS_CPP         |   ON    | Build C++ tests to verify library operation in C++. Requires `LEXBOR_BUILD_TESTS`.                        |
+| LEXBOR_BUILD_TESTS_CPP         |  OFF    | Build C++ tests to verify library operation in C++. Requires `LEXBOR_BUILD_TESTS`.                        |
 | LEXBOR_TEST_AMALGAMATION       |  OFF    | Build tests for the amalgamation file. Requires `LEXBOR_BUILD_TESTS`.                                     |
 | LEXBOR_BUILD_UTILS             |  OFF    | Build project utilities and helpers.                                                                      |
 | LEXBOR_BUILD_WITH_ASAN         |  OFF    | Enable Address Sanitizer if possible.                                                                     |
@@ -163,15 +163,15 @@ make
 
 We focus on minimal dependencies, custom algorithms, and platform-specific solutions:
 
-- The project is written in pure `C` without external prerequisites. We believe
-  in a "go hard or go home" approach.
+- The project is written in pure `C` without external prerequisites. We aim for
+  self-contained, minimal-dependency code.
 
 - While we're not reinventing every algorithm known to humankind, we handle
   object creation and memory management in our own way. Many classic algorithms
   used in `lexbor` are adapted to meet the specific needs of the project.
 
-- We're open to using third-party code, but it’s often simpler to start from
-  scratch than to add extra dependencies (looking at you, Node.js).
+- We're open to using third-party code, but it's often simpler to start from
+  scratch than to add extra dependencies.
 
 - Some functions are platform-dependent, such as threading, timers, I/O, and
   blocking primitives (spinlocks, mutexes). For these, we have a separate `port`
@@ -183,7 +183,7 @@ We focus on minimal dependencies, custom algorithms, and platform-specific solut
 
 There are four main dynamic memory functions:
 
-```c
+```C
 void *
 lexbor_malloc(size_t size);
 
@@ -199,10 +199,10 @@ lexbor_free(void *dst);
 
 These functions:
 
-- Are defined in `/source/lexbor/core/lexbor.h` (in the [core](#core) module).
+- Are defined in `source/lexbor/core/lexbor.h` (in the [core](#core) module).
 
-- Are implemented in `/source/port/*/lexbor/core/memory.c` (in the `port`
-  module).
+- Are implemented in `source/lexbor/ports/*/lexbor/core/memory.c` (in the
+  `ports` module).
 
 - Can be redefined if needed.
 
@@ -212,7 +212,7 @@ As the names suggest, they serve as replacements for the standard `malloc`,
 function returns a `void *` that is always `NULL`. This simplifies the process
 of nullifying freed variables:
 
-```c
+```C
 if (object->table != NULL) {
     object->table = lexbor_free(object->table);
 }
@@ -220,7 +220,7 @@ if (object->table != NULL) {
 
 Without this, you'd need to explicitly nullify `object->table`:
 
-```c
+```C
 if (object->table != NULL) {
     lexbor_free(object->table);
     object->table = NULL;
@@ -243,8 +243,8 @@ If a function can fail, it should report the failure. We follow two main rules w
 
 
 Status codes are passed as `lxb_status_t`. This type is defined throughout the
-codebase in `/source/lexbor/core/types.h`, and all available status codes are
-listed in `/source/lexbor/core/base.h`.
+codebase in `source/lexbor/core/types.h`, and all available status codes are
+listed in `source/lexbor/core/base.h`.
 
 
 ## Function Naming
@@ -260,7 +260,7 @@ Most functions follow this naming pattern:
 </style>
 
 
-The exception is the [core](#core) module (`/source/lexbor/core/`), which uses a
+The exception is the [core](#core) module (`source/lexbor/core/`), which uses a
 different pattern:
 
 [naming2]: img/naming2.png
@@ -278,11 +278,11 @@ without exceptions.
 
 ## Header Locations
 
-All paths are relative to the `/source/` directory. For example, to include a
-header file from the [html](#html) module located in `/source/lexbor/html/`,
+All paths are relative to the `source/` directory. For example, to include a
+header file from the [html](#html) module located in `source/lexbor/html/`,
 use:
 
-```c
+```C
 #include "lexbor/html/tree.h"
 ```
 
@@ -291,7 +291,7 @@ use:
 Most structures and objects have an API for creating, initializing, cleaning,
 and deleting them. This follows the general pattern:
 
-```c
+```C
 <structure-name> *
 <function-prefix>_create(void);
 
@@ -315,7 +315,7 @@ void
   typically return `void`.
 
 - If `NULL` is passed as the first argument (the object) to the `*_init`
-  function, it returns `LXB_STATUS_ERROR_OBJECT_NULL`.
+  function, it returns `LXB_STATUS_ERROR_OBJECT_IS_NULL`.
 
 - When the `*_destroy` function is called with `self_destroy` set to `true`, the
   returned value is always `NULL`; otherwise, the object (`obj`) is returned.
@@ -329,36 +329,38 @@ void
 
 Typical usage:
 
-```c
+```C
 lexbor_avl_t *avl = lexbor_avl_create();
-lxb_status_t status = lexbor_avl_init(avl, 1024);
+lxb_status_t status = lexbor_avl_init(avl, 1024,
+                                      sizeof(lexbor_avl_node_t));
 
 if (status != LXB_STATUS_OK) {
-    lexbor_avl_node_destroy(avl, true);
+    lexbor_avl_destroy(avl, true);
 
     exit(EXIT_FAILURE);
 }
 
 /* Do something super useful */
 
-lexbor_avl_node_destroy(avl, true);
+lexbor_avl_destroy(avl, true);
 ```
 
 Now, with an object on the stack:
 
-```c
+```C
 lexbor_avl_t avl = {0};
-lxb_status_t status = lexbor_avl_init(&avl, 1024);
+lxb_status_t status = lexbor_avl_init(&avl, 1024,
+                                       sizeof(lexbor_avl_node_t));
 
 if (status != LXB_STATUS_OK) {
-    lexbor_avl_node_destroy(&avl, false);
+    lexbor_avl_destroy(&avl, false);
 
     exit(EXIT_FAILURE);
 }
 
 /* Do something even more useful */
 
-lexbor_avl_node_destroy(&avl, false);
+lexbor_avl_destroy(&avl, false);
 ```
 
 Note that this approach is not an absolute requirement, even though it is
@@ -371,23 +373,24 @@ The `lexbor` project is designed to be modular, allowing each module to be built
 separately if desired. Modules can depend on each other; for instance, all
 modules currently rely on the [core](#core) module.
 
-Each module is located in a subdirectory within the `/source/` directory of the
+Each module is located in a subdirectory within the `source/` directory of the
 project.
 
 
 ### Module Versioning
 
 Each module records its version in the `base.h` file located at the module root.
-For example, see `/source/lexbor/html/base.h`:
+For example, see `source/lexbor/html/base.h`:
 
-```c
+```C
 #define <MODULE-NAME>_VERSION_MAJOR 1
 #define <MODULE-NAME>_VERSION_MINOR 0
 #define <MODULE-NAME>_VERSION_PATCH 3
 
-#define <MODULE-NAME>_VERSION_STRING LXB_STR(<MODULE-NAME>_VERSION_MAJOR) LXB_STR(.) \
-                                     LXB_STR(<MODULE-NAME>_VERSION_MINOR) LXB_STR(.) \
-                                     LXB_STR(<MODULE-NAME>_VERSION_PATCH)
+#define <MODULE-NAME>_VERSION_STRING                                  \
+    LEXBOR_STRINGIZE(<MODULE-NAME>_VERSION_MAJOR) "."                  \
+    LEXBOR_STRINGIZE(<MODULE-NAME>_VERSION_MINOR) "."                  \
+    LEXBOR_STRINGIZE(<MODULE-NAME>_VERSION_PATCH)
 ```
 
 
@@ -398,7 +401,7 @@ as AVL and BST trees, arrays, and strings. It also handles memory management.
 The module is continuously evolving with new algorithms being added and existing
 ones optimized.
 
-Documentation for this module will be available later.
+See the [Core module documentation](modules/core) for API reference.
 
 
 ### DOM
@@ -406,7 +409,7 @@ Documentation for this module will be available later.
 This module implements the [DOM specification](https://dom.spec.whatwg.org/).
 Its functions manage the DOM tree, including its nodes, attributes, and events.
 
-Documentation for this module will be available later.
+See the [DOM module documentation](modules/dom) for API reference.
 
 
 ### HTML
@@ -417,8 +420,7 @@ specification](https://html.spec.whatwg.org/multipage/).
 Current implementations include: Tokenizer, Tree Builder, Parser, Fragment
 Parser, and Interfaces for HTML Elements.
 
-Documentation for this module will be available later. For guidance, refer to
-the
+See the [HTML module documentation](modules/html) for API reference. Also see the
 [HTML examples](https://github.com/lexbor/lexbor/tree/master/examples/lexbor/html) in our repo
 or the corresponding [articles](articles/index).
 
@@ -440,9 +442,8 @@ windows-1255, windows-1256, windows-1257, windows-1258, windows-874,
 x-mac-cyrillic, x-user-defined
 ```
 
-Documentation for this module will be available later. For guidance, refer to
-the [Encoding
-examples](https://github.com/lexbor/lexbor/tree/master/examples/lexbor/encoding)
+See the [Encoding module documentation](modules/encoding) for API reference. Also see the
+[Encoding examples](https://github.com/lexbor/lexbor/tree/master/examples/lexbor/encoding)
 in our repo or the corresponding [articles](articles/index).
 
 
@@ -450,7 +451,6 @@ in our repo or the corresponding [articles](articles/index).
 
 This module implements the [CSS specification](https://drafts.csswg.org/).
 
-Documentation for this module will be available later. For guidance, refer to
-the [CSS
-examples](https://github.com/lexbor/lexbor/tree/master/examples/lexbor/css) in
+See the [CSS module documentation](modules/css) for API reference. Also see the
+[CSS examples](https://github.com/lexbor/lexbor/tree/master/examples/lexbor/css) in
 our repo or the corresponding [articles](articles/index).
diff --git a/source/download.md b/source/download.md
index cad48aa..903bdab 100644
--- a/source/download.md
+++ b/source/download.md
@@ -4,19 +4,20 @@
 
 The `lexbor` binaries are available for:
 
-* [CentOS](#centos) 6, 7, 8
+* [CentOS](#centos) 7
 
-* [Debian](#debian) 8, 9, 10, 11
+* [Debian](#debian) 11, 12
 
-* [Fedora](#fedora) 28, 29, 30, 31, 32, 33, 34, 36, 37
+* [Fedora](#fedora) 39, 40, 41
 
-* [RHEL](#rhel) 7, 8
+* [RHEL](#rhel) 8, 9
 
-* [Ubuntu](#ubuntu) 14.04, 16.04, 18.04, 18.10, 19.04, 19.10, 20.04, 20.10,
-  21.04, 22.04
+* [Ubuntu](#ubuntu) 20.04, 22.04, 24.04
 
 * [macOS](#macos)
 
+**Note:** Older distribution versions that have reached end-of-life are no longer listed. If you need packages for an older version, check the repository at `packages.lexbor.com` directly.
+
 
 ### CentOS
 
@@ -52,14 +53,14 @@ curl https://lexbor.com/keys/lexbor_signing.key | \
  ```
 
 2. To configure the `lexbor` repository, create the following file named
-   `/etc/apt/sources.list.d/lexbor.list`. For Debian 11:
+   `/etc/apt/sources.list.d/lexbor.list`. For Debian 12:
 
  ```ini
-deb-src [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/debian/ bullseye liblexbor
-deb [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/debian/ bullseye liblexbor
+deb-src [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/debian/ bookworm liblexbor
+deb [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/debian/ bookworm liblexbor
  ```
 
- Supported distros also include `buster` (10), `stretch` (9), and `jessie` (8).
+ Supported distros also include `bullseye` (11).
 
 3. Install the core `lexbor` package and any additional packages you need:
 
@@ -86,8 +87,8 @@ deb [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/debian/
 2. Install the core `lexbor` package and any additional packages you need:
 
  ```sh
- yum install liblexbor
- yum install liblexbor-dev
+ dnf install liblexbor
+ dnf install liblexbor-devel
  ```
 
 
@@ -108,7 +109,7 @@ deb [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/debian/
 
  ```sh
  yum install liblexbor
- yum install liblexbor-dev
+ yum install liblexbor-devel
  ```
 
 
@@ -125,16 +126,14 @@ curl https://lexbor.com/keys/lexbor_signing.key | \
  ```
 
 2. To configure the `lexbor` repository, create the following file named
-   `/etc/apt/sources.list.d/lexbor.list`. For Ubuntu 20.04:
+   `/etc/apt/sources.list.d/lexbor.list`. For Ubuntu 22.04:
 
  ```ini
-deb-src [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/ubuntu/ focal liblexbor
-deb [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/ubuntu/ focal liblexbor
+deb-src [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/ubuntu/ jammy liblexbor
+deb [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/ubuntu/ jammy liblexbor
  ```
 
- Supported distros also include `hirsute` (21.04), `groovy` (20.10), `focal`
- (20.04), `eoan` (19.10), `disco` (19.04), `cosmic` (18.10), `bionic` (18.04),
- `xenial` (16.04), and `trusty` (14.04).
+ Supported distros also include `noble` (24.04) and `focal` (20.04).
 
 3. Install the core `lexbor` package and any additional packages you need:
 
@@ -145,7 +144,7 @@ deb [signed-by=/etc/apt/keyrings/lexbor.gpg] https://packages.lexbor.com/ubuntu/
  ```
 
 
-## macOS
+### macOS
 
 ### Homebrew
 
diff --git a/source/modules/core.md b/source/modules/core.md
index ba109a7..0e06472 100644
--- a/source/modules/core.md
+++ b/source/modules/core.md
@@ -8,41 +8,573 @@
 
 ## Overview
 
-The Core module is the foundation of lexbor. It implements essential data structures, algorithms, and memory management used by all other modules.
+The Core module is the foundation of lexbor. It implements essential data structures, memory management, and utilities used by all other modules. Written in pure C99 with zero external dependencies.
 
-Core provides the building blocks that all other modules depend on. It's written in pure C99 with zero external dependencies, making it highly portable and easy to embed.
+## Key Features
+
+- **Zero Dependencies** — pure C99, no external libraries required
+- **Object Lifecycle** — all types follow the `create`/`init`/`clean`/`destroy` pattern
+- **Dual Function Variants** — performance-critical accessors have both inline and non-inline (`_noi`) versions for ABI stability
+- **Pool Allocation** — `lexbor_dobject_t` recycles fixed-size objects; `lexbor_mraw_t` provides general-purpose pooled allocation
+- **Platform Abstraction** — portable across operating systems via `source/lexbor/ports/`
 
 ## What's Inside
 
-- **Memory Management** — custom allocators optimized for parser performance
-  - `lexbor_malloc`, `lexbor_calloc`, `lexbor_realloc`, `lexbor_free`
-  - Memory pools for fast object allocation
-
-- **Data Structures**
-  - AVL trees — self-balancing binary search trees
-  - BST trees — binary search trees
-  - Arrays — dynamic arrays with automatic growth
-  - Strings — efficient string handling with SSO (Small String Optimization)
-  - Hash tables — fast key-value lookups
-  - Vectors — generic dynamic arrays
-
-- **Base Types** — common types used across all modules
-  - `lxb_status_t` — status codes for error handling
-  - `lxb_char_t` — character type (unsigned char)
-  - `lxb_codepoint_t` — Unicode code point
-  - and more...
-
-- **Utilities**
-  - String operations (case conversion, comparison, hashing)
-  - Number parsing and conversion
-  - Bit operations
-  - Debugging helpers
+- **[Status Codes](#status-codes-lxb_status_t)** — error handling codes used by all modules
+- **[Action Type](#action-type-lexbor_action_t)** — callback return values for iteration control
+- **[Base Types](#base-types)** — common types used across all modules
+- **[Memory Allocator](#memory-allocator-lexbor_mraw_t)** — pooled memory allocator with caching
+- **[Dynamic Object Pool](#dynamic-object-pool-lexbor_dobject_t)** — fixed-size object pool allocator
+- **[Array](#array-lexbor_array_t)** — dynamic array of void pointers
+- **[Object Array](#object-array-lexbor_array_obj_t)** — dynamic array storing objects by value
+- **[String](#string-lexbor_str_t)** — dynamically resizable string
+- **[Hash Table](#hash-table-lexbor_hash_t)** — hash table with short string optimization
+- **[AVL Tree](#avl-tree-lexbor_avl_t)** — self-balancing AVL tree
 
-## Key Features
+## Quick Start
+
+### Using Arrays and Strings
+
+```C
+#include <lexbor/core/core.h>
+
+int main(void)
+{
+    lxb_status_t status;
+
+    /* Create a memory allocator */
+    lexbor_mraw_t *mraw = lexbor_mraw_create();
+    status = lexbor_mraw_init(mraw, 256);
+    if (status != LXB_STATUS_OK) {
+        return EXIT_FAILURE;
+    }
+
+    /* Create and populate an array */
+    lexbor_array_t *array = lexbor_array_create();
+    status = lexbor_array_init(array, 4);
+    if (status != LXB_STATUS_OK) {
+        lexbor_mraw_destroy(mraw, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Initialize a string */
+    lexbor_str_t str = {0};
+    lxb_char_t *data = lexbor_str_init(&str, mraw, 32);
+    if (data == NULL) {
+        lexbor_array_destroy(array, true);
+        lexbor_mraw_destroy(mraw, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Append text to the string */
+    lexbor_str_append(&str, mraw,
+                      (const lxb_char_t *) "Hello, lexbor!", 14);
+
+    /* Store the string pointer in the array */
+    lexbor_array_push(array, &str);
+
+    printf("String: %.*s (length: %zu)\n",
+           (int) str.length, str.data, str.length);
+    printf("Array length: %zu\n", lexbor_array_length(array));
+
+    /* Cleanup */
+    lexbor_str_destroy(&str, mraw, false);
+    lexbor_array_destroy(array, true);
+    lexbor_mraw_destroy(mraw, true);
+
+    return EXIT_SUCCESS;
+}
+```
+
+**Output:**
+```
+String: Hello, lexbor! (length: 14)
+Array length: 1
+```
+
+## Status Codes (`lxb_status_t`)
+
+All lexbor functions return `lxb_status_t` for error handling. Defined in `source/lexbor/core/base.h`.
+
+### Location
+
+Status codes are defined in `source/lexbor/core/base.h`.
+
+```C
+typedef enum {
+    LXB_STATUS_OK                      = 0x0000,
+    LXB_STATUS_ERROR                   = 0x0001,
+    LXB_STATUS_ERROR_MEMORY_ALLOCATION,
+    LXB_STATUS_ERROR_OBJECT_IS_NULL,
+    LXB_STATUS_ERROR_SMALL_BUFFER,
+    LXB_STATUS_ERROR_INCOMPLETE_OBJECT,
+    LXB_STATUS_ERROR_NO_FREE_SLOT,
+    LXB_STATUS_ERROR_TOO_SMALL_SIZE,
+    LXB_STATUS_ERROR_NOT_EXISTS,
+    LXB_STATUS_ERROR_WRONG_ARGS,
+    LXB_STATUS_ERROR_WRONG_STAGE,
+    LXB_STATUS_CONTINUE,
+    LXB_STATUS_STOP,
+    LXB_STATUS_ABORTED,
+    LXB_STATUS_STOPPED,
+    LXB_STATUS_NEXT,
+    LXB_STATUS_WARNING
+} lxb_status_t;
+```
+
+`LXB_STATUS_OK` (`0x0000`) indicates success. All other values indicate errors or control flow signals.
+
+
+## Action Type (`lexbor_action_t`)
+
+Used as callback return values to control iteration:
+
+### Location
+
+Defined in `source/lexbor/core/base.h`.
+
+```C
+typedef enum {
+    LEXBOR_ACTION_OK   = 0x00,  /* continue */
+    LEXBOR_ACTION_STOP = 0x01,  /* stop iteration */
+    LEXBOR_ACTION_NEXT = 0x02   /* skip to next */
+} lexbor_action_t;
+```
+
+
+## Base Types
+
+Common types used across all modules (defined in `source/lexbor/core/base.h`):
+
+### Location
+
+Defined in `source/lexbor/core/base.h`.
+
+- `lxb_char_t` — character type (`unsigned char`)
+- `lxb_codepoint_t` — Unicode code point
+- `lexbor_serialize_cb_f` — serialization callback: `lxb_status_t (*)(const lxb_char_t *data, size_t len, void *ctx)`
+- `lexbor_callback_f` — general callback: `lxb_status_t (*)(const lxb_char_t *data, size_t len, void *ctx)`
+
+
+## Memory Allocator (`lexbor_mraw_t`)
+
+A pooled memory allocator with caching for reallocation. Used throughout lexbor for efficient allocation. Defined in `source/lexbor/core/mraw.h`.
+
+### Location
+
+Declared in `source/lexbor/core/mraw.h`.
+
+```C
+typedef struct {
+    lexbor_mem_t  *mem;
+    lexbor_bst_t  *cache;
+    size_t        ref_count;
+} lexbor_mraw_t;
+```
+
+### Lifecycle
+
+```C
+lexbor_mraw_t *
+lexbor_mraw_create(void);
+
+lxb_status_t
+lexbor_mraw_init(lexbor_mraw_t *mraw, size_t chunk_size);
+
+void
+lexbor_mraw_clean(lexbor_mraw_t *mraw);
+
+lexbor_mraw_t *
+lexbor_mraw_destroy(lexbor_mraw_t *mraw, bool destroy_self);
+```
+
+### Allocation
+
+```C
+void *lexbor_mraw_alloc(lexbor_mraw_t *mraw, size_t size);
+void *lexbor_mraw_calloc(lexbor_mraw_t *mraw, size_t size);
+void *lexbor_mraw_realloc(lexbor_mraw_t *mraw, void *data, size_t new_size);
+void  lexbor_mraw_free(lexbor_mraw_t *mraw, void *data);
+```
+
+### Utility
+
+```C
+/* Duplicate a memory block */
+void *lexbor_mraw_dup(lexbor_mraw_t *mraw, const void *src, size_t size);
+
+/* Get the allocated size of a block */
+size_t lexbor_mraw_data_size(void *data);
+
+/* Get reference count */
+size_t lexbor_mraw_reference_count(lexbor_mraw_t *mraw);
+```
+
+
+## Dynamic Object Pool (`lexbor_dobject_t`)
+
+A pool allocator for frequently created and destroyed fixed-size objects. Allocates objects from chunks and recycles freed objects via an internal cache. Defined in `source/lexbor/core/dobject.h`.
+
+### Location
+
+Declared in `source/lexbor/core/dobject.h`.
+
+```C
+typedef struct {
+    lexbor_mem_t   *mem;
+    lexbor_array_t *cache;
+    size_t         allocated;
+    size_t         struct_size;
+} lexbor_dobject_t;
+```
+
+### Lifecycle
+
+```C
+lexbor_dobject_t *
+lexbor_dobject_create(void);
+
+lxb_status_t
+lexbor_dobject_init(lexbor_dobject_t *dobject, size_t chunk_size, size_t struct_size);
+
+void
+lexbor_dobject_clean(lexbor_dobject_t *dobject);
+
+lexbor_dobject_t *
+lexbor_dobject_destroy(lexbor_dobject_t *dobject, bool destroy_self);
+```
+
+### Operations
+
+```C
+void *lexbor_dobject_alloc(lexbor_dobject_t *dobject);   /* allocate (uninitialized) */
+void *lexbor_dobject_calloc(lexbor_dobject_t *dobject);  /* allocate (zeroed) */
+void *lexbor_dobject_free(lexbor_dobject_t *dobject, void *data);  /* return to pool */
+
+void *lexbor_dobject_by_absolute_position(lexbor_dobject_t *dobject, size_t pos);
+
+size_t lexbor_dobject_allocated(lexbor_dobject_t *dobject);      /* total allocated */
+size_t lexbor_dobject_cache_length(lexbor_dobject_t *dobject);   /* cached (free) count */
+```
+
+
+## Array (`lexbor_array_t`)
+
+A dynamic array of `void *` pointers. Defined in `source/lexbor/core/array.h`.
+
+### Location
+
+Declared in `source/lexbor/core/array.h`.
+
+```C
+typedef struct {
+    void   **list;
+    size_t size;      /* capacity */
+    size_t length;    /* current count */
+} lexbor_array_t;
+```
+
+### Lifecycle
+
+```C
+lexbor_array_t *
+lexbor_array_create(void);
+
+lxb_status_t
+lexbor_array_init(lexbor_array_t *array, size_t size);
+
+void
+lexbor_array_clean(lexbor_array_t *array);
+
+lexbor_array_t *
+lexbor_array_destroy(lexbor_array_t *array, bool self_destroy);
+```
+
+### Operations
+
+```C
+void **   lexbor_array_expand(lexbor_array_t *array, size_t up_to);
+lxb_status_t lexbor_array_push(lexbor_array_t *array, void *value);
+void *       lexbor_array_pop(lexbor_array_t *array);
+lxb_status_t lexbor_array_insert(lexbor_array_t *array, size_t idx, void *value);
+lxb_status_t lexbor_array_set(lexbor_array_t *array, size_t idx, void *value);
+void         lexbor_array_delete(lexbor_array_t *array, size_t begin, size_t length);
+
+void * lexbor_array_get(const lexbor_array_t *array, size_t idx);  /* NULL if out of bounds */
+size_t lexbor_array_length(lexbor_array_t *array);
+size_t lexbor_array_size(lexbor_array_t *array);
+```
+
+
+## Object Array (`lexbor_array_obj_t`)
+
+A dynamic array that stores objects by value (not by pointer). Elements are stored in a contiguous byte buffer, accessed by index and struct size. Defined in `source/lexbor/core/array_obj.h`.
+
+### Location
+
+Declared in `source/lexbor/core/array_obj.h`.
+
+```C
+typedef struct {
+    uint8_t *list;
+    size_t  size;          /* capacity */
+    size_t  length;        /* current count */
+    size_t  struct_size;   /* size of each element */
+} lexbor_array_obj_t;
+```
+
+### Lifecycle
+
+```C
+lexbor_array_obj_t *
+lexbor_array_obj_create(void);
+
+lxb_status_t
+lexbor_array_obj_init(lexbor_array_obj_t *array, size_t size, size_t struct_size);
+
+void
+lexbor_array_obj_clean(lexbor_array_obj_t *array);
+
+lexbor_array_obj_t *
+lexbor_array_obj_destroy(lexbor_array_obj_t *array, bool self_destroy);
+```
+
+### Operations
+
+```C
+void *lexbor_array_obj_push(lexbor_array_obj_t *array);       /* allocate and zero at end */
+void *lexbor_array_obj_push_wo_cls(lexbor_array_obj_t *array); /* allocate without zeroing */
+void *lexbor_array_obj_push_n(lexbor_array_obj_t *array, size_t count); /* allocate N */
+void *lexbor_array_obj_pop(lexbor_array_obj_t *array);         /* remove last */
+void  lexbor_array_obj_delete(lexbor_array_obj_t *array, size_t begin, size_t length);
+
+void * lexbor_array_obj_get(const lexbor_array_obj_t *array, size_t idx);
+void * lexbor_array_obj_last(lexbor_array_obj_t *array);
+size_t lexbor_array_obj_length(lexbor_array_obj_t *array);
+size_t lexbor_array_obj_size(lexbor_array_obj_t *array);
+size_t lexbor_array_obj_struct_size(lexbor_array_obj_t *array);
+```
+
+Note: `push()` returns a pointer to the newly allocated slot in the array. The caller writes the object data into this slot.
+
+
+## String (`lexbor_str_t`)
+
+Dynamically resizable string. Uses `lexbor_mraw_t` for memory allocation. Defined in `source/lexbor/core/str.h`.
+
+### Location
+
+Declared in `source/lexbor/core/str.h`.
+
+```C
+typedef struct {
+    lxb_char_t *data;
+    size_t     length;
+} lexbor_str_t;
+```
+
+### Lifecycle
+
+```C
+lexbor_str_t *
+lexbor_str_create(void);
+
+lxb_char_t *
+lexbor_str_init(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t size);
+
+lxb_char_t *
+lexbor_str_init_append(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                       const lxb_char_t *data, size_t length);
+
+void
+lexbor_str_clean(lexbor_str_t *str);
+
+void
+lexbor_str_clean_all(lexbor_str_t *str);
+
+lexbor_str_t *
+lexbor_str_destroy(lexbor_str_t *str, lexbor_mraw_t *mraw, bool destroy_obj);
+```
+
+### Operations
+
+```C
+/* Resize */
+lxb_char_t *lexbor_str_realloc(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t new_size);
+lxb_char_t *lexbor_str_check_size(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t plus_len);
+
+/* Append */
+lxb_char_t *lexbor_str_append(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                               const lxb_char_t *data, size_t length);
+lxb_char_t *lexbor_str_append_before(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                                      const lxb_char_t *buff, size_t length);
+lxb_char_t *lexbor_str_append_one(lexbor_str_t *str, lexbor_mraw_t *mraw, lxb_char_t data);
+lxb_char_t *lexbor_str_append_lowercase(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                                         const lxb_char_t *data, size_t length);
+
+/* Copy */
+lxb_char_t *lexbor_str_copy(lexbor_str_t *dest, const lexbor_str_t *target,
+                             lexbor_mraw_t *mraw);
+
+/* Whitespace */
+void lexbor_str_stay_only_whitespace(lexbor_str_t *target);
+void lexbor_str_strip_collapse_whitespace(lexbor_str_t *target);
+void lexbor_str_crop_whitespace_from_begin(lexbor_str_t *target);
+```
+
+### Accessors
+
+```C
+lxb_char_t *lexbor_str_data(lexbor_str_t *str);
+size_t      lexbor_str_length(lexbor_str_t *str);
+size_t      lexbor_str_size(lexbor_str_t *str);
+```
+
+### Data Comparison Functions
+
+```C
+/* Exact match */
+bool lexbor_str_data_ncmp(const lxb_char_t *first,
+                           const lxb_char_t *sec, size_t size);
+bool lexbor_str_data_cmp(const lxb_char_t *first, const lxb_char_t *sec);
+
+/* Case-insensitive */
+bool lexbor_str_data_ncasecmp(const lxb_char_t *first,
+                               const lxb_char_t *sec, size_t size);
+bool lexbor_str_data_casecmp(const lxb_char_t *first, const lxb_char_t *sec);
+
+/* Substring search */
+bool lexbor_str_data_ncmp_contain(const lxb_char_t *where, size_t where_size,
+                                   const lxb_char_t *what, size_t what_size);
+bool lexbor_str_data_ncasecmp_contain(const lxb_char_t *where, size_t where_size,
+                                       const lxb_char_t *what, size_t what_size);
+
+/* Case conversion */
+void lexbor_str_data_to_lowercase(lxb_char_t *to, const lxb_char_t *from, size_t len);
+void lexbor_str_data_to_uppercase(lxb_char_t *to, const lxb_char_t *from, size_t len);
+```
+
+
+## Hash Table (`lexbor_hash_t`)
+
+Hash table with configurable key handling, collision chaining, and short string optimization for keys. Defined in `source/lexbor/core/hash.h`.
+
+### Location
+
+Declared in `source/lexbor/core/hash.h`.
+
+### Key Types
+
+```C
+typedef struct {
+    lexbor_dobject_t    *entries;
+    lexbor_mraw_t       *mraw;
+    lexbor_hash_entry_t **table;
+    size_t              table_size;
+    size_t              struct_size;
+} lexbor_hash_t;
+
+typedef struct {
+    union {
+        lxb_char_t *long_str;
+        lxb_char_t short_str[LEXBOR_HASH_SHORT_SIZE + 1];  /* 17 bytes inline */
+    } u;
+    size_t              length;
+    lexbor_hash_entry_t *next;
+} lexbor_hash_entry_t;
+```
+
+Hash entries use short string optimization: keys up to 16 bytes are stored inline in `short_str`, avoiding a separate allocation. `LEXBOR_HASH_SHORT_SIZE` is `16`.
+
+### Lifecycle
+
+```C
+lexbor_hash_t *
+lexbor_hash_create(void);
+
+lxb_status_t
+lexbor_hash_init(lexbor_hash_t *hash, size_t table_size, size_t struct_size);
+
+void
+lexbor_hash_clean(lexbor_hash_t *hash);
+
+lexbor_hash_t *
+lexbor_hash_destroy(lexbor_hash_t *hash, bool destroy_obj);
+```
+
+The `struct_size` parameter allows embedding custom data after the hash entry header. Pass `sizeof(lexbor_hash_entry_t)` for entries with no extra data.
+
+### Operations
+
+```C
+void *
+lexbor_hash_insert(lexbor_hash_t *hash, const lexbor_hash_insert_t *insert,
+                   const lxb_char_t *key, size_t length);
+
+lexbor_hash_entry_t *
+lexbor_hash_search(lexbor_hash_t *hash, const lexbor_hash_search_t *search,
+                   const lxb_char_t *key, size_t length);
+
+void
+lexbor_hash_remove(lexbor_hash_t *hash, const lexbor_hash_search_t *search,
+                   const lxb_char_t *key, size_t length);
+```
+
+Pre-defined insert/search strategies:
+
+- `lexbor_hash_insert_raw` / `lexbor_hash_search_raw` — exact key matching
+- `lexbor_hash_insert_lower` / `lexbor_hash_search_lower` — case-insensitive (lowercase)
+- `lexbor_hash_insert_upper` / `lexbor_hash_search_upper` — case-insensitive (uppercase)
+
+
+## AVL Tree (`lexbor_avl_t`)
+
+Self-balancing AVL tree for ordered data. Defined in `source/lexbor/core/avl.h`.
+
+### Location
+
+Declared in `source/lexbor/core/avl.h`.
+
+```C
+typedef struct {
+    lexbor_dobject_t  *nodes;
+    lexbor_avl_node_t *last_right;
+} lexbor_avl_t;
+
+typedef struct lexbor_avl_node {
+    size_t                  type;    /* key */
+    short                   height;
+    void                    *value;
+    struct lexbor_avl_node  *left;
+    struct lexbor_avl_node  *right;
+    struct lexbor_avl_node  *parent;
+} lexbor_avl_node_t;
+```
+
+### Lifecycle
+
+```C
+lexbor_avl_t *lexbor_avl_create(void);
+lxb_status_t  lexbor_avl_init(lexbor_avl_t *avl, size_t chunk_len,
+                              size_t struct_size);
+void          lexbor_avl_clean(lexbor_avl_t *avl);
+lexbor_avl_t *lexbor_avl_destroy(lexbor_avl_t *avl, bool self_destroy);
+```
+
+### Operations
+
+```C
+lexbor_avl_node_t *lexbor_avl_insert(lexbor_avl_t *avl, lexbor_avl_node_t **scope,
+                                      size_t type, void *value);
+lexbor_avl_node_t *lexbor_avl_search(lexbor_avl_t *avl, lexbor_avl_node_t *scope,
+                                      size_t type);
+void *             lexbor_avl_remove(lexbor_avl_t *avl, lexbor_avl_node_t **scope,
+                                      size_t type);
+
+lxb_status_t lexbor_avl_foreach(lexbor_avl_t *avl, lexbor_avl_node_t **scope,
+                                 lexbor_avl_node_f cb, void *ctx);
+```
+
+The `scope` parameter is a pointer to the root node pointer, allowing the tree to update the root during balancing.
 
-- **Zero Dependencies** — pure C99, no external libraries required
-- **Performance-Optimized** — custom algorithms tuned for parser workloads
-- **Memory Efficient** — pooled allocation reduces fragmentation
-- **Platform Abstraction** — portable across different operating systems
 
-*(Documentation is currently being developed, details will be available here soon.)*
diff --git a/source/modules/css.md b/source/modules/css.md
index c68642f..e2c3232 100644
--- a/source/modules/css.md
+++ b/source/modules/css.md
@@ -3,31 +3,514 @@
 * **Version:** 1.4.0
 * **Path:** `source/lexbor/css`
 * **Base Includes:** `lexbor/css/css.h`
-* **Examples:** `source/examples/css`
-* **Specification:** [CSS](https://www.w3.org/Style/CSS/)
+* **Examples:** `examples/lexbor/css`
+* **Specification:** [CSS Syntax Level 3](https://www.w3.org/TR/css-syntax-3/), [Selectors Level 4](https://www.w3.org/TR/selectors-4/), [CSSOM](https://www.w3.org/TR/cssom-1/)
 
 ## Overview
 
-The CSS module provides a complete CSS parser implementing `CSS Syntax Module Level 3`. It can parse stylesheets, inline styles, and build CSSOM trees.
+The CSS module provides a complete CSS parser implementing CSS Syntax Module Level 3. It can parse stylesheets, individual style rules, and declarations, building a rule tree that can be serialized back to CSS text.
 
-Full-featured CSS parser supporting CSS Syntax, Selectors, CSSOM, and gradual implementation of various CSS modules.
+The module includes:
+
+- **Syntax Tokenizer** — converts CSS text into tokens per CSS Syntax Level 3
+- **Parser** — builds a CSS rule tree from tokens
+- **Stylesheet** — parses and holds a complete stylesheet's rule tree
+- **Rule Tree** — CSSOM-style representation of style rules, at-rules, and declarations
+- **Property Parsing** — parses CSS property values into typed structures
+- **Selectors** — CSS Selectors Level 4 (documented separately in the [Selectors module](selectors.md))
+- **Log** — collects warnings and errors during parsing
+
+## Key Features
+
+- **CSS Syntax Level 3** — complete tokenizer and parser implementation
+- **CSS Selectors Level 4** — full selector parsing (see [Selectors module](selectors.md))
+- **CSS Namespaces Level 3** — complete namespace support
+- **CSSOM** — CSS Object Model (in progress)
+- **Property Value Parsing** — typed parsing for display, position, color, opacity, dimensions, margin, padding, border, background, font, text, flexbox, and more
 
 ## What's Inside
 
-- **Syntax Tokenizer** — converts CSS text into tokens
-- **Parser** — builds CSS rule tree from tokens
-- **CSSOM** — CSS Object Model
-- **Property Parsing** — parses CSS properties and values
-- **Value Types** — handles lengths, colors, functions
+- **[Quick Start](#quick-start)** — minimal working example to parse and serialize CSS
+- **[Parser](#parser-lxb_css_parser_t)** — core CSS parser entry point
+- **[Stylesheet](#stylesheet-lxb_css_stylesheet_t)** — parsed stylesheet representation
+- **[Rule Tree](#rule-tree)** — CSSOM-style rule node hierarchy
+- **[Serialization](#serialization)** — callback-based CSS text output
+- **[Log](#log-lxb_css_log_t)** — parser warnings and errors
+- **[Memory Management](#memory-management-lxb_css_memory_t)** — shared memory pool
+- **[Examples](#examples)** — complete working programs
+
+## Quick Start
+
+### Parsing and Serializing CSS
+
+```C
+#include <lexbor/css/css.h>
+
+static lxb_status_t
+serializer_callback(const lxb_char_t *data, size_t len, void *ctx)
+{
+    printf("%.*s", (int) len, data);
+    return LXB_STATUS_OK;
+}
+
+int main(void)
+{
+    lxb_status_t status;
+
+    static const lxb_char_t css[] = "div { color: red; display: flex; }";
+
+    /* Create and initialize the parser */
+    lxb_css_parser_t *parser = lxb_css_parser_create();
+    status = lxb_css_parser_init(parser, NULL);
+    if (status != LXB_STATUS_OK) {
+        return EXIT_FAILURE;
+    }
+
+    /* Create a stylesheet and parse CSS into it */
+    lxb_css_stylesheet_t *sst = lxb_css_stylesheet_create(NULL);
+    status = lxb_css_stylesheet_parse(sst, parser, css, sizeof(css) - 1);
+    if (status != LXB_STATUS_OK) {
+        lxb_css_stylesheet_destroy(sst, true);
+        lxb_css_parser_destroy(parser, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Serialize back to CSS text */
+    lxb_css_rule_serialize(sst->root, serializer_callback, NULL);
+    printf("\n");
+
+    lxb_css_stylesheet_destroy(sst, true);
+    lxb_css_parser_destroy(parser, true);
+
+    return EXIT_SUCCESS;
+}
+```
+
+
+## Parser (`lxb_css_parser_t`)
+
+The CSS parser is the core entry point. Defined in `source/lexbor/css/parser.h`.
+
+### Location
+
+Declared in `source/lexbor/css/parser.h`.
+
+### Lifecycle
+
+```C
+lxb_css_parser_t *
+lxb_css_parser_create(void);
+
+lxb_status_t
+lxb_css_parser_init(lxb_css_parser_t *parser, lxb_css_syntax_tokenizer_t *tkz);
+
+void
+lxb_css_parser_clean(lxb_css_parser_t *parser);
+
+void
+lxb_css_parser_erase(lxb_css_parser_t *parser);
+
+lxb_css_parser_t *
+lxb_css_parser_destroy(lxb_css_parser_t *parser, bool self_destroy);
+```
+
+- `lxb_css_parser_init()`: If `tkz` is `NULL`, the parser creates and manages its own tokenizer.
+- `lxb_css_parser_clean()`: Resets state but keeps allocated memory for reuse.
+- `lxb_css_parser_erase()`: Resets state and releases internal allocations.
+- `lxb_css_parser_destroy()`: If `self_destroy` is `true`, frees the parser object itself.
+
+### Selectors Integration
+
+To parse CSS that contains selectors (which is most CSS), initialize the selectors module:
+
+```C
+lxb_status_t
+lxb_css_parser_selectors_init(lxb_css_parser_t *parser);
+
+void
+lxb_css_parser_selectors_destroy(lxb_css_parser_t *parser);
+```
+
+If the selectors module is not initialized when parsing a stylesheet, one is created temporarily for each parse call. For better performance when parsing multiple stylesheets, initialize it once.
+
+### Status
+
+```C
+lxb_status_t
+lxb_css_parser_status(lxb_css_parser_t *parser);
+
+lxb_css_log_t *
+lxb_css_parser_log(lxb_css_parser_t *parser);
+```
+
+
+## Stylesheet (`lxb_css_stylesheet_t`)
+
+Represents a parsed CSS stylesheet. Defined in `source/lexbor/css/stylesheet.h`.
+
+### Location
+
+Declared in `source/lexbor/css/stylesheet.h`.
+
+### Lifecycle
+
+```C
+lxb_css_stylesheet_t *
+lxb_css_stylesheet_create(lxb_css_memory_t *memory);
+
+lxb_css_stylesheet_t *
+lxb_css_stylesheet_destroy(lxb_css_stylesheet_t *sst, bool destroy_memory);
+```
+
+- `lxb_css_stylesheet_create()`: If `memory` is `NULL`, the stylesheet creates its own memory pool.
+- `lxb_css_stylesheet_destroy()`: If `destroy_memory` is `true`, also destroys the associated memory pool.
+
+### Parsing
+
+```C
+lxb_status_t
+lxb_css_stylesheet_parse(lxb_css_stylesheet_t *sst, lxb_css_parser_t *parser,
+                         const lxb_char_t *data, size_t length);
+```
+
+Parses CSS text into the stylesheet's rule tree. Only returns errors for severe failures (e.g., out of memory). Invalid CSS is handled gracefully — broken rules are recorded as `lxb_css_rule_bad_style_t`.
+
+After parsing, the rule tree is available at `sst->root`.
+
+
+## Rule Tree
+
+The parsed CSS is represented as a tree of rule nodes. All rule types share a common base `lxb_css_rule_t`. Defined in `source/lexbor/css/rule.h`.
+
+### Location
+
+Defined in `source/lexbor/css/rule.h`.
+
+### Rule Types
+
+```C
+typedef enum {
+    LXB_CSS_RULE_UNDEF = 0,
+    LXB_CSS_RULE_STYLESHEET,
+    LXB_CSS_RULE_LIST,
+    LXB_CSS_RULE_AT_RULE,
+    LXB_CSS_RULE_STYLE,
+    LXB_CSS_RULE_BAD_STYLE,
+    LXB_CSS_RULE_DECLARATION_LIST,
+    LXB_CSS_RULE_DECLARATION
+} lxb_css_rule_type_t;
+```
+
+### Key Rule Structures
+
+**`lxb_css_rule_style_t`** — A CSS style rule (selector + declarations):
+
+```C
+struct lxb_css_rule_style {
+    lxb_css_rule_t                  rule;
+    lxb_css_selector_list_t         *selector;
+    lxb_css_rule_declaration_list_t *declarations;
+    /* ... */
+};
+```
+
+**`lxb_css_rule_declaration_t`** — A single CSS declaration (property: value):
+
+```C
+struct lxb_css_rule_declaration {
+    lxb_css_rule_t rule;
+    uintptr_t      type;      /* property ID from LXB_CSS_PROPERTY_* */
+    union { /* typed property value */ } u;
+    bool           important;
+};
+```
+
+The `type` field holds the property ID (e.g., `LXB_CSS_PROPERTY_DISPLAY`), and the union `u` holds the parsed value in a type-safe structure.
+
+**`lxb_css_rule_at_t`** — An at-rule (@media, @font-face, @namespace):
+
+```C
+struct lxb_css_rule_at {
+    lxb_css_rule_t rule;
+    uintptr_t      type;      /* at-rule ID from LXB_CSS_AT_RULE_* */
+    union { /* typed at-rule data */ } u;
+};
+```
+
+**`lxb_css_rule_bad_style_t`** — A style rule whose selector failed to parse:
+
+```C
+struct lxb_css_rule_bad_style {
+    lxb_css_rule_t                  rule;
+    lexbor_str_t                    selectors;  /* raw selector text */
+    lxb_css_rule_declaration_list_t *declarations;
+};
+```
+
+### Casting Macros
+
+```C
+lxb_css_rule(obj)               /* cast to lxb_css_rule_t *               */
+lxb_css_rule_style(obj)         /* cast to lxb_css_rule_style_t *         */
+lxb_css_rule_at(obj)            /* cast to lxb_css_rule_at_t *            */
+lxb_css_rule_declaration(obj)   /* cast to lxb_css_rule_declaration_t *   */
+lxb_css_rule_declaration_list(obj) /* cast to lxb_css_rule_declaration_list_t * */
+```
+
+### Traversal
+
+Rules form a linked list via `next`/`prev` pointers. List containers (`lxb_css_rule_list_t`, `lxb_css_rule_declaration_list_t`) have `first`/`last` pointers.
+
+```C
+/* Iterate over rules in a list */
+lxb_css_rule_t *rule = list->first;
+while (rule != NULL) {
+    /* process rule */
+    rule = rule->next;
+}
+```
+
+
+## Serialization
+
+All rule types support callback-based serialization back to CSS text.
+
+### Location
+
+Serialization functions are declared in `source/lexbor/css/rule.h`.
+
+```C
+lxb_status_t
+lxb_css_rule_serialize(const lxb_css_rule_t *rule,
+                       lexbor_serialize_cb_f cb, void *ctx);
+
+lxb_status_t
+lxb_css_rule_serialize_chain(const lxb_css_rule_t *rule,
+                             lexbor_serialize_cb_f cb, void *ctx);
+```
+
+- `lxb_css_rule_serialize()`: Serializes a single rule.
+- `lxb_css_rule_serialize_chain()`: Serializes a rule and all its `next` siblings.
+
+Type-specific serialization functions:
+
+```C
+lxb_css_rule_style_serialize(style, cb, ctx);
+lxb_css_rule_at_serialize(at, cb, ctx);
+lxb_css_rule_declaration_serialize(decl, cb, ctx);
+lxb_css_rule_declaration_list_serialize(list, cb, ctx);
+```
+
+The callback signature is `lexbor_serialize_cb_f`:
+
+```C
+typedef lxb_status_t
+(*lexbor_serialize_cb_f)(const lxb_char_t *data, size_t len, void *ctx);
+```
+
+
+## Log (`lxb_css_log_t`)
+
+The CSS parser log collects messages generated during parsing. Defined in `source/lexbor/css/log.h`.
+
+### Location
+
+Declared in `source/lexbor/css/log.h`.
+
+### Message Types
+
+```C
+typedef enum {
+    LXB_CSS_LOG_INFO = 0,
+    LXB_CSS_LOG_WARNING,
+    LXB_CSS_LOG_ERROR,
+    LXB_CSS_LOG_SYNTAX_ERROR
+} lxb_css_log_type_t;
+```
+
+### Lifecycle
+
+```C
+lxb_css_log_t *
+lxb_css_log_create(void);
+
+lxb_status_t
+lxb_css_log_init(lxb_css_log_t *log, lexbor_mraw_t *mraw);
+
+void
+lxb_css_log_clean(lxb_css_log_t *log);
+
+lxb_css_log_t *
+lxb_css_log_destroy(lxb_css_log_t *log, bool self_destroy);
+```
+
+### Usage
+
+```C
+/* Get the number of log messages */
+size_t
+lxb_css_log_length(lxb_css_log_t *log);
+
+/* Serialize all log messages */
+lxb_status_t
+lxb_css_log_serialize(lxb_css_log_t *log, lexbor_serialize_cb_f cb, void *ctx,
+                      const lxb_char_t *indent, size_t indent_length);
+
+/* Serialize to a string (caller must free with lexbor_free) */
+lxb_char_t *
+lxb_css_log_serialize_char(lxb_css_log_t *log, size_t *out_length,
+                           const lxb_char_t *indent, size_t indent_length);
+```
+
+
+## Memory Management (`lxb_css_memory_t`)
+
+The CSS module uses a shared memory pool for all allocations. Defined in `source/lexbor/css/base.h`.
+
+### Location
+
+Declared in `source/lexbor/css/base.h`.
+
+```C
+lxb_css_memory_t *
+lxb_css_memory_create(void);
+
+lxb_status_t
+lxb_css_memory_init(lxb_css_memory_t *memory, size_t prepare_count);
+
+void
+lxb_css_memory_clean(lxb_css_memory_t *memory);
+
+lxb_css_memory_t *
+lxb_css_memory_destroy(lxb_css_memory_t *memory, bool self_destroy);
+```
+
+The memory pool uses reference counting:
+
+```C
+lxb_css_memory_t *
+lxb_css_memory_ref_inc(lxb_css_memory_t *memory);
+
+void
+lxb_css_memory_ref_dec(lxb_css_memory_t *memory);
+
+lxb_css_memory_t *
+lxb_css_memory_ref_dec_destroy(lxb_css_memory_t *memory);
+```
+
+
+## Examples
+
+### Parsing and Serializing a Stylesheet
+
+```C
+#include <lexbor/css/css.h>
+
+static lxb_status_t
+serializer_callback(const lxb_char_t *data, size_t len, void *ctx)
+{
+    printf("%.*s", (int) len, data);
+    return LXB_STATUS_OK;
+}
+
+int
+main(void)
+{
+    lxb_status_t status;
+    lxb_css_parser_t *parser;
+    lxb_css_stylesheet_t *sst;
+
+    static const lxb_char_t css[] =
+        "div { color: red; display: flex; }"
+        "p.intro { font-size: 16px; margin: 10px; }";
+
+    /* Create and initialize the parser */
+    parser = lxb_css_parser_create();
+    status = lxb_css_parser_init(parser, NULL);
+    if (status != LXB_STATUS_OK) {
+        goto failed;
+    }
+
+    /* Create a stylesheet and parse CSS into it */
+    sst = lxb_css_stylesheet_create(NULL);
+    status = lxb_css_stylesheet_parse(sst, parser, css, sizeof(css) - 1);
+
+    lxb_css_parser_destroy(parser, true);
+
+    if (status != LXB_STATUS_OK) {
+        lxb_css_stylesheet_destroy(sst, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Serialize the parsed stylesheet back to CSS text */
+    lxb_css_rule_serialize(sst->root, serializer_callback, NULL);
+    printf("\n");
+
+    lxb_css_stylesheet_destroy(sst, true);
+    return EXIT_SUCCESS;
+
+failed:
+    lxb_css_parser_destroy(parser, true);
+    return EXIT_FAILURE;
+}
+```
+
+### Walking the Rule Tree
+
+```C
+#include <lexbor/css/css.h>
+
+static lxb_status_t
+print_cb(const lxb_char_t *data, size_t len, void *ctx)
+{
+    printf("%.*s", (int) len, data);
+    return LXB_STATUS_OK;
+}
+
+int
+main(void)
+{
+    lxb_status_t status;
+    lxb_css_parser_t *parser;
+    lxb_css_stylesheet_t *sst;
+    lxb_css_rule_t *rule;
+
+    static const lxb_char_t css[] =
+        ".header { color: blue; } .footer { margin: 0; }";
+
+    parser = lxb_css_parser_create();
+    status = lxb_css_parser_init(parser, NULL);
+    if (status != LXB_STATUS_OK) {
+        return EXIT_FAILURE;
+    }
+
+    sst = lxb_css_stylesheet_create(NULL);
+    status = lxb_css_stylesheet_parse(sst, parser, css, sizeof(css) - 1);
+    lxb_css_parser_destroy(parser, true);
+
+    if (status != LXB_STATUS_OK) {
+        lxb_css_stylesheet_destroy(sst, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Walk the rule list */
+    lxb_css_rule_list_t *list = lxb_css_rule_list(sst->root);
+    rule = list->first;
 
-## Supported Features
+    while (rule != NULL) {
+        printf("Rule type: %d\n", rule->type);
 
-- ✅ CSS Syntax Level 3
-- ✅ CSS Selectors Level 4
-- ✅ CSSOM
-- 🚧 CSS Values (in progress)
-- 🚧 CSS Box Model (in progress)
-- 🚧 CSS Display, Fonts, Flexbox (in progress)
+        if (rule->type == LXB_CSS_RULE_STYLE) {
+            printf("  Style rule: ");
+            lxb_css_rule_style_serialize(lxb_css_rule_style(rule),
+                                         print_cb, NULL);
+            printf("\n");
+        }
 
+        rule = rule->next;
+    }
 
-*(Documentation is currently being developed, details will be available here soon.)*
+    lxb_css_stylesheet_destroy(sst, true);
+    return EXIT_SUCCESS;
+}
+```
diff --git a/source/modules/dom.md b/source/modules/dom.md
index 391d431..0756559 100644
--- a/source/modules/dom.md
+++ b/source/modules/dom.md
@@ -3,22 +3,845 @@
 * **Version:** 2.0.0
 * **Path:** `source/lexbor/dom`
 * **Base Includes:** `lexbor/dom/dom.h`
-* **Examples:** not present
+* **Examples:** `examples/lexbor/html` (DOM is used through the HTML module)
 * **Specification:** [WHATWG DOM Living Standard](https://dom.spec.whatwg.org/)
 
 ## Overview
 
-The DOM module implements the Document Object Model specification, providing a tree structure for representing and manipulating HTML documents.
+The DOM module implements the Document Object Model specification, providing a tree structure for representing and manipulating HTML documents. It defines the node hierarchy, tree operations, element attributes, and namespace handling used throughout lexbor.
 
-Complete implementation of WHATWG DOM standard with efficient tree operations and namespace support.
+In practice, the DOM module is most commonly used via the [HTML module](html.md). After parsing HTML with `lxb_html_document_parse()`, you interact with the resulting tree using DOM types and functions.
+
+## Key Features
+
+- **Specification Compliant** — implements WHATWG DOM Living Standard
+- **Full Node Hierarchy** — elements, text, comments, processing instructions, document fragments
+- **Tree Operations** — insert, remove, replace, clone, walk with callbacks
+- **Element Search** — find by ID, tag name, class name, attribute values
+- **Attribute Operations** — get, set, remove, iterate attributes
+- **Collections** — dynamic arrays for holding multiple node references
+- **Namespace Support** — HTML, SVG, MathML, XLink, XML, XMLNS
+- **Inheritance Pattern** — "poor man's inheritance" with safe casting macros
 
 ## What's Inside
 
-- **Node Hierarchy** — all DOM node types (Element, Text, Comment, etc.)
-- **Node Operations** — create, append, insert, remove, replace
-- **Element Operations** — attribute manipulation
-- **Tree Traversal** — parent, children, siblings navigation
-- **Namespace Support** — HTML, SVG, MathML, XML
+- **[Quick Start](#quick-start)** — minimal working example for DOM traversal
+- **[Key Types](#key-types)** — node types, interface hierarchy, and casting macros
+- **[Node](#node-lxb_dom_node_t)** — traversal, properties, modification, text content, walking
+- **[Element](#element-lxb_dom_element_t)** — names, attributes, search, lifecycle
+- **[Attribute](#attribute-lxb_dom_attr_t)** — attribute name and value access
+- **[Document](#document-lxb_dom_document_t)** — document node, factory methods, lifecycle
+- **[Collection](#collection-lxb_dom_collection_t)** — dynamic array for holding node references
+- **[Namespace Support](#namespace-support)** — XML namespace handling
+- **[Examples](#examples)** — complete working programs
+
+## Quick Start
+
+### Iterating Child Elements
+
+```C
+#include <lexbor/html/parser.h>
+#include <lexbor/dom/interfaces/element.h>
+
+int main(void)
+{
+    lxb_status_t status;
+    lxb_html_document_t *document;
+    lxb_dom_node_t *child;
+
+    static const lxb_char_t html[] =
+        "<div>First</div><p>Second</p><span>Third</span>";
+
+    document = lxb_html_document_create();
+    status = lxb_html_document_parse(document, html, sizeof(html) - 1);
+    if (status != LXB_STATUS_OK) {
+        lxb_html_document_destroy(document);
+        return EXIT_FAILURE;
+    }
+
+    lxb_dom_element_t *body = lxb_dom_interface_element(document->body);
+
+    child = lxb_dom_node_first_child(lxb_dom_interface_node(body));
+    while (child != NULL) {
+        if (lxb_dom_node_type(child) == LXB_DOM_NODE_TYPE_ELEMENT) {
+            const lxb_char_t *name;
+            name = lxb_dom_element_local_name(
+                lxb_dom_interface_element(child), NULL);
+            printf("Element: %s\n", (const char *) name);
+        }
+        child = lxb_dom_node_next(child);
+    }
+
+    lxb_html_document_destroy(document);
+    return EXIT_SUCCESS;
+}
+```
+
+**Output:**
+```
+Element: div
+Element: p
+Element: span
+```
+
+## Key Types
+
+### Node Types
+
+Every node in the DOM tree has a type defined by `lxb_dom_node_type_t`:
+
+```C
+typedef enum {
+    LXB_DOM_NODE_TYPE_UNDEF                  = 0x00,
+    LXB_DOM_NODE_TYPE_ELEMENT                = 0x01,
+    LXB_DOM_NODE_TYPE_ATTRIBUTE              = 0x02,
+    LXB_DOM_NODE_TYPE_TEXT                    = 0x03,
+    LXB_DOM_NODE_TYPE_CDATA_SECTION          = 0x04,
+    LXB_DOM_NODE_TYPE_ENTITY_REFERENCE       = 0x05, // historical
+    LXB_DOM_NODE_TYPE_ENTITY                 = 0x06, // historical
+    LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION = 0x07,
+    LXB_DOM_NODE_TYPE_COMMENT                = 0x08,
+    LXB_DOM_NODE_TYPE_DOCUMENT               = 0x09,
+    LXB_DOM_NODE_TYPE_DOCUMENT_TYPE          = 0x0A,
+    LXB_DOM_NODE_TYPE_DOCUMENT_FRAGMENT      = 0x0B,
+    LXB_DOM_NODE_TYPE_NOTATION               = 0x0C, // historical
+    LXB_DOM_NODE_TYPE_CHARACTER_DATA,
+    LXB_DOM_NODE_TYPE_SHADOW_ROOT,
+    LXB_DOM_NODE_TYPE_LAST_ENTRY
+} lxb_dom_node_type_t;
+```
+
+### Interface Hierarchy
+
+The DOM module uses a "poor man's inheritance" pattern where each structure embeds its parent as the first field, allowing safe casting between types:
+
+```
+lxb_dom_event_target_t
+  └── lxb_dom_node_t
+        ├── lxb_dom_element_t
+        ├── lxb_dom_document_t
+        ├── lxb_dom_character_data_t
+        │     ├── lxb_dom_text_t
+        │     ├── lxb_dom_comment_t
+        │     ├── lxb_dom_cdata_section_t
+        │     └── lxb_dom_processing_instruction_t
+        ├── lxb_dom_document_type_t
+        ├── lxb_dom_document_fragment_t
+        ├── lxb_dom_shadow_root_t
+        └── lxb_dom_attr_t
+```
+
+### Interface Casting Macros
+
+Because of the inheritance pattern, casting macros are provided in `source/lexbor/dom/interface.h`:
+
+```C
+lxb_dom_interface_node(obj)      /* cast to lxb_dom_node_t *    */
+lxb_dom_interface_element(obj)   /* cast to lxb_dom_element_t * */
+lxb_dom_interface_document(obj)  /* cast to lxb_dom_document_t * */
+lxb_dom_interface_text(obj)      /* cast to lxb_dom_text_t *    */
+lxb_dom_interface_comment(obj)   /* cast to lxb_dom_comment_t * */
+lxb_dom_interface_attr(obj)      /* cast to lxb_dom_attr_t *    */
+```
+
+For example, to get the node type of an element:
+
+```C
+lxb_dom_element_t *element = /* ... */;
+lxb_dom_node_type_t type = lxb_dom_node_type(lxb_dom_interface_node(element));
+```
+
+
+## Node (`lxb_dom_node_t`)
+
+The fundamental type for all DOM tree nodes. Defined in `source/lexbor/dom/interfaces/node.h`.
+
+### Location
+
+Declared in `source/lexbor/dom/interfaces/node.h`.
+
+### Tree Traversal
+
+Navigate the tree using these inline functions:
+
+```C
+lxb_dom_node_t *
+lxb_dom_node_first_child(lxb_dom_node_t *node);
+
+lxb_dom_node_t *
+lxb_dom_node_last_child(lxb_dom_node_t *node);
+
+lxb_dom_node_t *
+lxb_dom_node_next(lxb_dom_node_t *node);
+
+lxb_dom_node_t *
+lxb_dom_node_prev(lxb_dom_node_t *node);
+
+lxb_dom_node_t *
+lxb_dom_node_parent(lxb_dom_node_t *node);
+```
+
+All return `NULL` when no such node exists.
+
+### Node Properties
+
+```C
+/* Get the node type */
+lxb_dom_node_type_t
+lxb_dom_node_type(lxb_dom_node_t *node);
+
+/* Get the tag ID (element local name as numeric ID) */
+lxb_tag_id_t
+lxb_dom_node_tag_id(lxb_dom_node_t *node);
+
+/* Get the node name as a string */
+const lxb_char_t *
+lxb_dom_node_name(lxb_dom_node_t *node, size_t *len);
+```
+
+### Tree Modification
+
+**Low-level operations** — These insert/remove nodes directly without DOM spec validation:
+
+```C
+/* Insert node as the last child of 'to' */
+void
+lxb_dom_node_insert_child(lxb_dom_node_t *to, lxb_dom_node_t *node);
+
+/* Insert node immediately before 'to' */
+void
+lxb_dom_node_insert_before(lxb_dom_node_t *to, lxb_dom_node_t *node);
+
+/* Insert node immediately after 'to' */
+void
+lxb_dom_node_insert_after(lxb_dom_node_t *to, lxb_dom_node_t *node);
+
+/* Remove node from its parent */
+void
+lxb_dom_node_remove(lxb_dom_node_t *node);
+```
+
+**Spec-compliant operations** — These perform DOM spec validation before modifying the tree, returning an exception code:
+
+```C
+/* Node.appendChild(node) — validates, then appends child */
+lxb_dom_exception_code_t
+lxb_dom_node_append_child(lxb_dom_node_t *parent, lxb_dom_node_t *node);
+
+/* Node.insertBefore(node, child) — validates, then inserts */
+lxb_dom_exception_code_t
+lxb_dom_node_insert_before_spec(lxb_dom_node_t *dst, lxb_dom_node_t *node,
+                                lxb_dom_node_t *child);
+
+/* Node.removeChild(child) — validates, then removes */
+lxb_dom_exception_code_t
+lxb_dom_node_remove_child(lxb_dom_node_t *parent, lxb_dom_node_t *child);
+
+/* Node.replaceChild(node, child) — validates, then replaces */
+lxb_dom_exception_code_t
+lxb_dom_node_replace_child(lxb_dom_node_t *parent, lxb_dom_node_t *node,
+                           lxb_dom_node_t *child);
+```
+
+Returns `LXB_DOM_EXCEPTION_OK` on success.
+
+### Text Content
+
+```C
+/* Get text content of the node and its descendants.
+ * Memory is freed when the document is destroyed.
+ * To free earlier, call lxb_dom_document_destroy_text(). */
+lxb_char_t *
+lxb_dom_node_text_content(lxb_dom_node_t *node, size_t *len);
+
+/* Set text content, replacing all children */
+lxb_status_t
+lxb_dom_node_text_content_set(lxb_dom_node_t *node,
+                              const lxb_char_t *content, size_t len);
+```
+
+### Tree Walking
+
+Walk all descendants of a node using a callback:
+
+```C
+typedef lexbor_action_t
+(*lxb_dom_node_simple_walker_f)(lxb_dom_node_t *node, void *ctx);
+
+void
+lxb_dom_node_simple_walk(lxb_dom_node_t *root,
+                         lxb_dom_node_simple_walker_f walker_cb, void *ctx);
+```
+
+The callback should return `LEXBOR_ACTION_OK` to continue or `LEXBOR_ACTION_STOP` to stop.
+
+### Search Functions
+
+Find nodes within a subtree:
+
+```C
+/* Find the first element with the given ID */
+lxb_dom_node_t *
+lxb_dom_node_by_id(lxb_dom_node_t *root,
+                   const lxb_char_t *qualified_name, size_t len);
+
+/* Collect all elements with the given tag name */
+lxb_status_t
+lxb_dom_node_by_tag_name(lxb_dom_node_t *root, lxb_dom_collection_t *collection,
+                         const lxb_char_t *qualified_name, size_t len);
+
+/* Collect all elements with the given class name */
+lxb_status_t
+lxb_dom_node_by_class_name(lxb_dom_node_t *root,
+                           lxb_dom_collection_t *collection,
+                           const lxb_char_t *class_name, size_t len);
+
+/* Collect elements by attribute name and value (exact match) */
+lxb_status_t
+lxb_dom_node_by_attr(lxb_dom_node_t *root, lxb_dom_collection_t *collection,
+                     const lxb_char_t *qualified_name, size_t qname_len,
+                     const lxb_char_t *value, size_t value_len,
+                     bool case_insensitive);
+
+/* Collect elements by attribute value prefix */
+lxb_status_t
+lxb_dom_node_by_attr_begin(lxb_dom_node_t *root,
+                           lxb_dom_collection_t *collection,
+                           const lxb_char_t *qualified_name, size_t qname_len,
+                           const lxb_char_t *value, size_t value_len,
+                           bool case_insensitive);
+
+/* Collect elements by attribute value suffix */
+lxb_status_t
+lxb_dom_node_by_attr_end(lxb_dom_node_t *root, lxb_dom_collection_t *collection,
+                         const lxb_char_t *qualified_name, size_t qname_len,
+                         const lxb_char_t *value, size_t value_len,
+                         bool case_insensitive);
+
+/* Collect elements by attribute value substring */
+lxb_status_t
+lxb_dom_node_by_attr_contain(lxb_dom_node_t *root,
+                             lxb_dom_collection_t *collection,
+                             const lxb_char_t *qualified_name, size_t qname_len,
+                             const lxb_char_t *value, size_t value_len,
+                             bool case_insensitive);
+```
+
+### Destroy
+
+```C
+/* Destroy a single node (does not remove children) */
+lxb_dom_node_t *
+lxb_dom_node_destroy(lxb_dom_node_t *node);
+
+/* Destroy a node and all its descendants */
+lxb_dom_node_t *
+lxb_dom_node_destroy_deep(lxb_dom_node_t *root);
+
+/* Clone a node, optionally with all descendants */
+lxb_dom_node_t *
+lxb_dom_node_clone(lxb_dom_node_t *node, bool deep);
+```
+
+
+## Element (`lxb_dom_element_t`)
+
+Extends `lxb_dom_node_t` for elements. Defined in `source/lexbor/dom/interfaces/element.h`.
+
+### Location
+
+Declared in `source/lexbor/dom/interfaces/element.h`.
+
+### Element Names
+
+```C
+/* Original qualified name (e.g. "LalAla:DiV") */
+const lxb_char_t *
+lxb_dom_element_qualified_name(lxb_dom_element_t *element, size_t *len);
+
+/* Uppercase qualified name */
+const lxb_char_t *
+lxb_dom_element_qualified_name_upper(lxb_dom_element_t *element, size_t *len);
+
+/* Local name only (without prefix) */
+const lxb_char_t *
+lxb_dom_element_local_name(lxb_dom_element_t *element, size_t *len);
+
+/* Tag name (uppercase qualified name) */
+const lxb_char_t *
+lxb_dom_element_tag_name(lxb_dom_element_t *element, size_t *len);
+
+/* Namespace prefix */
+const lxb_char_t *
+lxb_dom_element_prefix(lxb_dom_element_t *element, size_t *len);
+
+/* Tag ID and namespace ID as numeric values */
+lxb_tag_id_t
+lxb_dom_element_tag_id(lxb_dom_element_t *element);
+
+lxb_ns_id_t
+lxb_dom_element_ns_id(lxb_dom_element_t *element);
+```
+
+### Attribute Operations
+
+```C
+/* Set or create an attribute */
+lxb_dom_attr_t *
+lxb_dom_element_set_attribute(lxb_dom_element_t *element,
+                              const lxb_char_t *qualified_name, size_t qn_len,
+                              const lxb_char_t *value, size_t value_len);
+
+/* Get an attribute value */
+const lxb_char_t *
+lxb_dom_element_get_attribute(lxb_dom_element_t *element,
+                              const lxb_char_t *qualified_name, size_t qn_len,
+                              size_t *value_len);
+
+/* Remove an attribute */
+lxb_status_t
+lxb_dom_element_remove_attribute(lxb_dom_element_t *element,
+                                 const lxb_char_t *qualified_name, size_t qn_len);
+
+/* Check if attribute exists */
+bool
+lxb_dom_element_has_attribute(lxb_dom_element_t *element,
+                              const lxb_char_t *qualified_name, size_t qn_len);
+
+/* Check if element has any attributes */
+bool
+lxb_dom_element_has_attributes(lxb_dom_element_t *element);
+```
+
+### Attribute Iteration
+
+```C
+lxb_dom_attr_t *
+lxb_dom_element_first_attribute(lxb_dom_element_t *element);
+
+lxb_dom_attr_t *
+lxb_dom_element_last_attribute(lxb_dom_element_t *element);
+
+lxb_dom_attr_t *
+lxb_dom_element_next_attribute(lxb_dom_attr_t *attr);
+
+lxb_dom_attr_t *
+lxb_dom_element_prev_attribute(lxb_dom_attr_t *attr);
+```
+
+### ID and Class Access
+
+```C
+/* Get the element's "id" attribute value */
+const lxb_char_t *
+lxb_dom_element_id(lxb_dom_element_t *element, size_t *len);
+
+/* Get the element's "class" attribute value */
+const lxb_char_t *
+lxb_dom_element_class(lxb_dom_element_t *element, size_t *len);
+
+/* Direct access to the id/class attribute objects */
+lxb_dom_attr_t *
+lxb_dom_element_id_attribute(lxb_dom_element_t *element);
+
+lxb_dom_attr_t *
+lxb_dom_element_class_attribute(lxb_dom_element_t *element);
+```
+
+### Element Search
+
+These functions search from the element downward and collect results into a collection:
+
+```C
+/* Find the first element with the given ID */
+lxb_dom_element_t *
+lxb_dom_element_by_id(lxb_dom_element_t *root,
+                      const lxb_char_t *qualified_name, size_t len);
+
+/* Collect elements by tag name */
+lxb_status_t
+lxb_dom_elements_by_tag_name(lxb_dom_element_t *root,
+                             lxb_dom_collection_t *collection,
+                             const lxb_char_t *qualified_name, size_t len);
+
+/* Collect elements by class name */
+lxb_status_t
+lxb_dom_elements_by_class_name(lxb_dom_element_t *root,
+                               lxb_dom_collection_t *collection,
+                               const lxb_char_t *class_name, size_t len);
+
+/* Collect elements by attribute (exact, prefix, suffix, substring) */
+lxb_status_t
+lxb_dom_elements_by_attr(lxb_dom_element_t *root,
+                         lxb_dom_collection_t *collection,
+                         const lxb_char_t *qualified_name, size_t qname_len,
+                         const lxb_char_t *value, size_t value_len,
+                         bool case_insensitive);
+```
+
+Variants `lxb_dom_elements_by_attr_begin()`, `lxb_dom_elements_by_attr_end()`, and `lxb_dom_elements_by_attr_contain()` match by attribute value prefix, suffix, and substring respectively.
+
+### Lifecycle
+
+```C
+lxb_dom_element_t *
+lxb_dom_element_create(lxb_dom_document_t *document,
+                       const lxb_char_t *local_name, size_t lname_len,
+                       const lxb_char_t *ns_name, size_t ns_len,
+                       const lxb_char_t *prefix, size_t prefix_len,
+                       const lxb_char_t *is, size_t is_len,
+                       bool sync_custom);
+
+lxb_dom_element_t *
+lxb_dom_element_destroy(lxb_dom_element_t *element);
+```
+
+In most cases, prefer `lxb_dom_document_create_element()` (see below) instead of calling `lxb_dom_element_create()` directly.
+
+
+## Attribute (`lxb_dom_attr_t`)
+
+Represents a single attribute on an element. Defined in `source/lexbor/dom/interfaces/attr.h`.
+
+### Location
+
+Declared in `source/lexbor/dom/interfaces/attr.h`.
+
+```C
+/* Get the local name of the attribute */
+const lxb_char_t *
+lxb_dom_attr_local_name(lxb_dom_attr_t *attr, size_t *len);
+
+/* Get the qualified name (including prefix) */
+const lxb_char_t *
+lxb_dom_attr_qualified_name(lxb_dom_attr_t *attr, size_t *len);
+
+/* Get the attribute value */
+const lxb_char_t *
+lxb_dom_attr_value(lxb_dom_attr_t *attr, size_t *len);
+
+/* Set the attribute value */
+lxb_status_t
+lxb_dom_attr_set_value(lxb_dom_attr_t *attr,
+                       const lxb_char_t *value, size_t value_len);
+```
+
+
+## Document (`lxb_dom_document_t`)
+
+The document node — the root of the DOM tree. Defined in `source/lexbor/dom/interfaces/document.h`.
+
+### Location
+
+Declared in `source/lexbor/dom/interfaces/document.h`.
+
+When working with HTML, you typically use `lxb_html_document_t` (from the [HTML module](html.md)) rather than `lxb_dom_document_t` directly.
+
+### Compatibility Mode
+
+```C
+typedef enum {
+    LXB_DOM_DOCUMENT_CMODE_NO_QUIRKS       = 0x00,
+    LXB_DOM_DOCUMENT_CMODE_QUIRKS          = 0x01,
+    LXB_DOM_DOCUMENT_CMODE_LIMITED_QUIRKS  = 0x02
+} lxb_dom_document_cmode_t;
+```
+
+### Factory Methods
+
+Create new DOM nodes owned by the document:
+
+```C
+lxb_dom_element_t *
+lxb_dom_document_create_element(lxb_dom_document_t *document,
+                                const lxb_char_t *local_name, size_t lname_len,
+                                void *reserved_for_opt);
+
+lxb_dom_text_t *
+lxb_dom_document_create_text_node(lxb_dom_document_t *document,
+                                  const lxb_char_t *data, size_t len);
+
+lxb_dom_comment_t *
+lxb_dom_document_create_comment(lxb_dom_document_t *document,
+                                const lxb_char_t *data, size_t len);
+
+lxb_dom_cdata_section_t *
+lxb_dom_document_create_cdata_section(lxb_dom_document_t *document,
+                                      const lxb_char_t *data, size_t len);
+
+lxb_dom_processing_instruction_t *
+lxb_dom_document_create_processing_instruction(lxb_dom_document_t *document,
+                                               const lxb_char_t *target, size_t target_len,
+                                               const lxb_char_t *data, size_t data_len);
+
+lxb_dom_document_fragment_t *
+lxb_dom_document_create_document_fragment(lxb_dom_document_t *document);
+```
+
+### Document Access
+
+```C
+/* Get the root node of the document tree */
+lxb_dom_node_t *
+lxb_dom_document_root(lxb_dom_document_t *document);
+
+/* Get the document element (e.g. <html>) */
+lxb_dom_element_t *
+lxb_dom_document_element(lxb_dom_document_t *document);
+
+/* Import a node from another document */
+lxb_dom_node_t *
+lxb_dom_document_import_node(lxb_dom_document_t *doc, lxb_dom_node_t *node,
+                             bool deep);
+```
+
+### Lifecycle
+
+```C
+lxb_dom_document_t *
+lxb_dom_document_create(lxb_dom_document_t *owner);
+
+lxb_status_t
+lxb_dom_document_init(lxb_dom_document_t *document, lxb_dom_document_t *owner,
+                      lxb_dom_interface_create_f create_interface,
+                      lxb_dom_interface_clone_f clone_interface,
+                      lxb_dom_interface_destroy_f destroy_interface,
+                      lxb_dom_document_dtype_t type, unsigned int ns);
+
+lxb_status_t
+lxb_dom_document_clean(lxb_dom_document_t *document);
+
+lxb_dom_document_t *
+lxb_dom_document_destroy(lxb_dom_document_t *document);
+```
+
+
+## Collection (`lxb_dom_collection_t`)
+
+A dynamic array for holding references to multiple DOM nodes. Used with search functions that return multiple results. Defined in `source/lexbor/dom/collection.h`.
+
+### Location
+
+Declared in `source/lexbor/dom/collection.h`.
+
+### Lifecycle
+
+```C
+lxb_dom_collection_t *
+lxb_dom_collection_create(lxb_dom_document_t *document);
+
+lxb_status_t
+lxb_dom_collection_init(lxb_dom_collection_t *col, size_t start_list_size);
+
+lxb_dom_collection_t *
+lxb_dom_collection_destroy(lxb_dom_collection_t *col, bool self_destroy);
+```
+
+Or use the convenience function that creates and initializes in one call:
+
+```C
+lxb_dom_collection_t *
+lxb_dom_collection_make(lxb_dom_document_t *document, size_t start_list_size);
+```
+
+### Usage
+
+```C
+void
+lxb_dom_collection_clean(lxb_dom_collection_t *col);
+
+lxb_status_t
+lxb_dom_collection_append(lxb_dom_collection_t *col, void *value);
+
+lxb_dom_element_t *
+lxb_dom_collection_element(lxb_dom_collection_t *col, size_t idx);
+
+lxb_dom_node_t *
+lxb_dom_collection_node(lxb_dom_collection_t *col, size_t idx);
+
+size_t
+lxb_dom_collection_length(lxb_dom_collection_t *col);
+```
+
+
+## Namespace Support
+
+The DOM module supports six XML namespaces, managed by the NS module:
+
+- **HTML** (`LXB_NS_HTML`)
+- **SVG** (`LXB_NS_SVG`)
+- **MathML** (`LXB_NS_MATH`)
+- **XLink** (`LXB_NS_XLINK`)
+- **XML** (`LXB_NS_XML`)
+- **XMLNS** (`LXB_NS_XMLNS`)
+
+Namespace IDs are accessed via `lxb_dom_element_ns_id()` or the `ns` field of `lxb_dom_node_t`.
+
+
+## Examples
+
+### Iterating Child Elements
+
+```C
+#include <lexbor/html/parser.h>
+#include <lexbor/dom/interfaces/element.h>
+
+int
+main(void)
+{
+    lxb_status_t status;
+    lxb_html_document_t *document;
+    lxb_dom_element_t *body;
+    lxb_dom_node_t *child;
+
+    static const lxb_char_t html[] =
+        "<div>First</div><p>Second</p><span>Third</span>";
+
+    document = lxb_html_document_create();
+    status = lxb_html_document_parse(document, html, sizeof(html) - 1);
+    if (status != LXB_STATUS_OK) {
+        goto failed;
+    }
+
+    body = lxb_dom_interface_element(document->body);
+
+    child = lxb_dom_node_first_child(lxb_dom_interface_node(body));
+    while (child != NULL) {
+        if (lxb_dom_node_type(child) == LXB_DOM_NODE_TYPE_ELEMENT) {
+            const lxb_char_t *name;
+            name = lxb_dom_element_local_name(lxb_dom_interface_element(child),
+                                              NULL);
+            printf("Element: %s\n", (const char *) name);
+        }
+
+        child = lxb_dom_node_next(child);
+    }
+
+    lxb_html_document_destroy(document);
+    return EXIT_SUCCESS;
+
+failed:
+    lxb_html_document_destroy(document);
+    return EXIT_FAILURE;
+}
+```
+
+**Output:**
+```
+Element: div
+Element: p
+Element: span
+```
+
+### Searching by Attribute
+
+```C
+#include <lexbor/html/parser.h>
+#include <lexbor/dom/interfaces/element.h>
+
+int
+main(void)
+{
+    lxb_status_t status;
+    lxb_html_document_t *document;
+    lxb_dom_collection_t *collection;
+
+    static const lxb_char_t html[] =
+        "<div class=\"active\">One</div>"
+        "<p class=\"active\">Two</p>"
+        "<span>Three</span>";
+
+    document = lxb_html_document_create();
+    status = lxb_html_document_parse(document, html, sizeof(html) - 1);
+    if (status != LXB_STATUS_OK) {
+        goto failed;
+    }
+
+    collection = lxb_dom_collection_make(
+        lxb_dom_interface_document(document), 16);
+    if (collection == NULL) {
+        goto failed;
+    }
+
+    status = lxb_dom_elements_by_class_name(
+        lxb_dom_interface_element(document->body),
+        collection,
+        (const lxb_char_t *) "active", 6);
+    if (status != LXB_STATUS_OK) {
+        goto cleanup;
+    }
+
+    for (size_t i = 0; i < lxb_dom_collection_length(collection); i++) {
+        lxb_dom_element_t *el = lxb_dom_collection_element(collection, i);
+        const lxb_char_t *name = lxb_dom_element_local_name(el, NULL);
+        printf("Found: %s\n", (const char *) name);
+    }
+
+    lxb_dom_collection_destroy(collection, true);
+    lxb_html_document_destroy(document);
+    return EXIT_SUCCESS;
+
+cleanup:
+    lxb_dom_collection_destroy(collection, true);
+failed:
+    lxb_html_document_destroy(document);
+    return EXIT_FAILURE;
+}
+```
+
+**Output:**
+```
+Found: div
+Found: p
+```
+
+### Walking the DOM Tree
+
+```C
+#include <lexbor/html/parser.h>
+#include <lexbor/dom/interfaces/element.h>
+
+static lexbor_action_t
+walker(lxb_dom_node_t *node, void *ctx)
+{
+    size_t *count = (size_t *) ctx;
+    if (lxb_dom_node_type(node) == LXB_DOM_NODE_TYPE_ELEMENT) {
+        (*count)++;
+    }
+    return LEXBOR_ACTION_OK;
+}
+
+int
+main(void)
+{
+    lxb_status_t status;
+    lxb_html_document_t *document;
+    size_t count = 0;
+
+    static const lxb_char_t html[] =
+        "<div><p><span>text</span></p></div><ul><li>item</li></ul>";
+
+    document = lxb_html_document_create();
+    status = lxb_html_document_parse(document, html, sizeof(html) - 1);
+    if (status != LXB_STATUS_OK) {
+        lxb_html_document_destroy(document);
+        return EXIT_FAILURE;
+    }
+
+    lxb_dom_node_simple_walk(
+        lxb_dom_interface_node(document->body), walker, &count);
+
+    /* count includes <body> itself */
+    printf("Elements in body: %zu\n", count);
+
+    lxb_html_document_destroy(document);
+    return EXIT_SUCCESS;
+}
+```
 
+**Output:**
+```
+Elements in body: 6
+```
 
-*(Documentation is currently being developed, details will be available here soon.)*
+The count includes `<body>`, `<div>`, `<p>`, `<span>`, `<ul>`, and `<li>`.
diff --git a/source/modules/encoding.md b/source/modules/encoding.md
index 2f5114e..94edc2d 100644
--- a/source/modules/encoding.md
+++ b/source/modules/encoding.md
@@ -38,7 +38,7 @@ The module provides comprehensive support for 40+ character encodings used acros
 
 ```C
 #include <lexbor/encoding/encoding.h>
-#include <lexbor/core/core.h> /* For lexbor_str() */
+#include <lexbor/core/core.h> /* For lexbor_str_t and lexbor_str() */
 
 int main(void)
 {
@@ -110,7 +110,7 @@ Decoding Windows-1251 to Unicode codepoints:
 
 ```C
 #include <lexbor/encoding/encoding.h>
-#include <lexbor/core/core.h> /* For lexbor_str() */
+#include <lexbor/core/core.h> /* For lexbor_str_t and lexbor_str() */
 
 int main(void)
 {
@@ -260,14 +260,14 @@ The simplest way to decode data when you have the entire input in memory.
 - **Pointer Updates**: Input and output pointers are advanced automatically
 - **No Null Termination**: Output is not null-terminated automatically
 
-#### Error Handling
+#### Buffer-Pass Error Handling
 
 - `LXB_STATUS_OK` — is returned on successful decoding.
 - `LXB_STATUS_CONTINUE` — not enough data for decoding, more data is needed. You need to run the same decoding function with the continuation of the data.
 - `LXB_STATUS_SMALL_BUFFER` — not enough buffer size to write decoded data.
 - `LXB_STATUS_ERROR` — is returned for decoding errors; is returned only if no replacement character was set by user (the lxb_encoding_encode_replace_set() function).
 
-#### Error Handling
+#### Streaming Error Handling
 
 The streaming decoder returns a codepoint or an error, i.e., a value greater than the maximum possible Unicode codepoint (cp > LXB_ENCODING_DECODE_MAX_CODEPOINT).
 
diff --git a/source/modules/html.md b/source/modules/html.md
index a1f303e..0123452 100644
--- a/source/modules/html.md
+++ b/source/modules/html.md
@@ -159,7 +159,7 @@ int main(void) {
 
     /* Feed HTML chunks as they arrive */
     lxb_html_document_parse_chunk(doc, html_1, sizeof(html_1) - 1);
-    lxb_html_document_parse_chunk(doc, html_1, sizeof(html_2) - 1);
+    lxb_html_document_parse_chunk(doc, html_2, sizeof(html_2) - 1);
 
     /* Finalize parsing */
     lxb_html_document_parse_chunk_end(doc);
@@ -173,7 +173,7 @@ int main(void) {
 
 #### Fragment Parsing (innerHTML)
 
-Parse HTML fragments with a context element:
+Parse HTML fragments with a context element (see [Parsing HTML Fragment](#parsing-html-fragment) for the full API):
 
 ```C
 #include <lexbor/html/html.h>
@@ -542,10 +542,10 @@ The functions output valid HTML as required by the specification.
 |----------|-------------|
 | `lxb_html_serialize_str()` | Serialize single node to string (no children) |
 | `lxb_html_serialize_cb()` | Serialize single node via callback (no children) |
-| `lxb_html_serialize_tree_str()` | Serialize node with direct children to string |
-| `lxb_html_serialize_tree_cb()` | Serialize node with direct children via callback |
-| `lxb_html_serialize_deep_str()` | Serialize direct children (without node) to string |
-| `lxb_html_serialize_deep_cb()` | Serialize direct children (without node) via callback |
+| `lxb_html_serialize_tree_str()` | Serialize node and all descendants to string |
+| `lxb_html_serialize_tree_cb()` | Serialize node and all descendants via callback |
+| `lxb_html_serialize_deep_str()` | Serialize all descendants (without node itself) to string |
+| `lxb_html_serialize_deep_cb()` | Serialize all descendants (without node itself) via callback |
 
 #### Pretty Print Functions
 
@@ -555,10 +555,10 @@ The functions generate “pretty” HTML that is not valid; for easy to read and
 |----------|-------------|
 | `lxb_html_serialize_pretty_str()` | Pretty print single node to string |
 | `lxb_html_serialize_pretty_cb()` | Pretty print single node via callback |
-| `lxb_html_serialize_pretty_tree_str()` | Pretty print node with children to string |
-| `lxb_html_serialize_pretty_tree_cb()` | Pretty print node with children via callback |
-| `lxb_html_serialize_pretty_deep_str()` | Pretty print direct children (without node) to string |
-| `lxb_html_serialize_pretty_deep_cb()` | Pretty print direct children (without node) via callback |
+| `lxb_html_serialize_pretty_tree_str()` | Pretty print node and all descendants to string |
+| `lxb_html_serialize_pretty_tree_cb()` | Pretty print node and all descendants via callback |
+| `lxb_html_serialize_pretty_deep_str()` | Pretty print all descendants (without node itself) to string |
+| `lxb_html_serialize_pretty_deep_cb()` | Pretty print all descendants (without node itself) via callback |
 
 ### String vs Callback Output
 
@@ -777,7 +777,7 @@ if (status != LXB_STATUS_OK) {
 
 ## Element Interfaces
 
-The HTML module implements over 90 element interfaces (like `lxb_html_div_element_t`, `lxb_html_input_element_t`, etc.) that correspond to HTML elements. These interfaces use a "poor man's inheritance" pattern — a technique for simulating object-oriented inheritance in C through struct composition.
+The HTML module implements over 90 element interfaces (like `lxb_html_div_element_t`, `lxb_html_input_element_t`, etc.) that correspond to HTML elements. These interfaces use a "poor man's inheritance" pattern — a technique for simulating object-oriented inheritance in C through struct composition. For the underlying DOM node and element APIs, see the [DOM module](dom.md).
 
 ### Location
 
@@ -954,7 +954,7 @@ lxb_ns_id_enum_t;
 ```
 
 You can find all namespace IDs in `source/lexbor/ns/const.h`.
-For more details, see the Namespaces Modul (`ns`).
+For more details, see the Namespaces Module (`ns`).
 
 **Usage:**
 
@@ -981,7 +981,7 @@ typedef enum {
     /* ... HTML tags ... */
     LXB_TAG_DIV          = 0x0033,  // <div>
     LXB_TAG_INPUT        = 0x006a,  // <input>
-    LXB_TAG_SPAN         = 0x00c0,  // <span>
+    LXB_TAG_SPAN         = 0x00aa,  // <span>
     LXB_TAG_BODY         = 0x001f,  // <body>
     LXB_TAG_A            = 0x0006,  // <a>
     /* ... 90+ more tags ... */
@@ -1713,5 +1713,5 @@ lxb_html_encoding_t *lxb_html_encoding_destroy(lxb_html_encoding_t *em, bool sel
 
 1. **First Wins**: When multiple encoding declarations are found, only the first valid one should be used (though the detector returns all found declarations).
 2. **Not Full Parsing**: This is a lightweight scanner, not a full HTML parser. It's designed specifically for quick encoding detection.
-3. **BOM Not Handled**: This detector only searches for `<meta>` tag declarations. Byte Order Mark (BOM) detection should be handled separately if needed.
+3. **BOM Not Handled**: This detector only searches for `<meta>` tag declarations. Byte Order Mark (BOM) detection should be handled separately if needed. See the [Encoding module](encoding.md) for BOM handling and full encoding support.
 4. **Case Insensitive**: Tag names and attribute names are matched case-insensitively, following HTML parsing rules.
diff --git a/source/modules/index.md b/source/modules/index.md
index 1493a06..feb18c9 100644
--- a/source/modules/index.md
+++ b/source/modules/index.md
@@ -31,7 +31,7 @@ This architecture offers several practical benefits:
 All modules are located in the `source/lexbor/` directory of the project. Each module has:
 
 - A `base.h` file with version information and type definitions
-- A `config.cmake` file for build configuration
+- A `config.cmake` file for build configuration (most modules)
 - Implementation files (`.c`) and headers (`.h`)
 
 ## Available Modules
@@ -47,10 +47,10 @@ These modules are stable, fully tested, and ready for production use:
 | [DOM](/modules/dom/) | 2.0.0 | [WHATWG DOM](https://dom.spec.whatwg.org/) | DOM tree manipulation |
 | [CSS](/modules/css/) | 1.4.0 | [CSS](https://www.w3.org/Style/CSS/) | CSS parser and CSS modules |
 | [Selectors](/modules/selectors/) | 0.5.0 | [CSS Selectors Level 4](https://drafts.csswg.org/selectors-4/) | CSS selectors engine |
-| [Encoding](/modules/encoding/) | 2.2.0 | [WHATWG Encoding](https://encoding.spec.whatwg.org/) | 40+ character encodings |
+| [Encoding](/modules/encoding/) | 2.2.0 | [WHATWG Encoding](https://encoding.spec.whatwg.org/) | 39 character encodings |
 | [URL](/modules/url/) | 0.4.0 | [WHATWG URL](https://url.spec.whatwg.org/) | URL parsing and manipulation |
-| [Unicode](/modules/unicode/) | 0.5.0 | [Unicode TR#15](https://www.unicode.org/reports/tr15/), [TR#46](https://unicode.org/reports/tr46/) | Normalization and IDNA |
-| Punycode | — | [RFC 3492](https://www.rfc-editor.org/rfc/rfc3492.html) | Punycode encoding/decoding |
+| [Unicode](/modules/unicode/) | 0.4.0 | [Unicode TR#15](https://www.unicode.org/reports/tr15/), [TR#46](https://unicode.org/reports/tr46/) | Normalization and IDNA |
+| Punycode | 1.1.0 | [RFC 3492](https://www.rfc-editor.org/rfc/rfc3492.html) | Punycode encoding/decoding |
 
 ### Supporting Modules
 
@@ -80,7 +80,7 @@ Each module maintains its own version number. Versions follow semantic versionin
 - **Minor** — new features, backward compatible
 - **Patch** — bug fixes, backward compatible
 
-```c
+```C
 #include <lexbor/html/base.h>
 
 printf("HTML module version: %s\n", LXB_HTML_VERSION_STRING);
@@ -89,12 +89,9 @@ printf("Core version: %s\n", LEXBOR_VERSION_STRING);
 
 Or:
 
-```c
+```C
 printf("Core version: %d.%d.%d\n",
        LEXBOR_VERSION_MAJOR,
        LEXBOR_VERSION_MINOR,
        LEXBOR_VERSION_PATCH);
 ```
-
-
-*(Documentation is currently being developed, details will be available here soon.)*
\ No newline at end of file
diff --git a/source/modules/selectors.md b/source/modules/selectors.md
index 8de12ca..2aa6bf2 100644
--- a/source/modules/selectors.md
+++ b/source/modules/selectors.md
@@ -9,7 +9,7 @@
 ## Overview
 
 The Selectors module implements DOM node search by selectors. In other words, it combines three modules: DOM, HTML, and CSS selectors.
-This module, which forms the basis for `querySelector` and `querySelectorAll`.
+It forms the basis for `querySelector` and `querySelectorAll`.
 
 For parsing HTML documents, use the [HTML module](html.md).
 For CSS selector parsing, use the [CSS module](css.md).
@@ -24,7 +24,7 @@ For CSS selector parsing, use the [CSS module](css.md).
 
 ## Quick Start
 
-```c
+```C
 #include <lexbor/html/html.h>
 #include <lexbor/css/css.h>
 #include <lexbor/selectors/selectors.h>
@@ -44,7 +44,7 @@ find_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t spec, void *c
     return LXB_STATUS_OK;
 }
 
-int main(int argc, const char *argv[])
+int main(void)
 {
     lxb_status_t status;
     const lxb_char_t html[] = "<div class='container'><p>Hello</p><p>World</p></div>";
@@ -97,6 +97,11 @@ int main(int argc, const char *argv[])
 
 ## Supported Selectors
 
+### Location
+
+Selector parsing functions are declared in `source/lexbor/css/selectors.h`.
+The selectors engine is declared in `source/lexbor/selectors/selectors.h`.
+
 ### Basic Selectors
 
 #### Type Selectors
@@ -258,7 +263,7 @@ Combinators combine multiple selectors to create relationships:
 
 ### Complex Selectors with Pseudo-classes
 
-```c
+```C
 /* Find all checked checkboxes in a form */
 const lxb_char_t selector1[] = "form input[type='checkbox']:checked";
 
@@ -271,7 +276,7 @@ const lxb_char_t selector4[] = "article > p:first-of-type";
 
 ### Using :is() and :where() for Grouping
 
-```c
+```C
 /* Match any heading */
 const lxb_char_t selector1[] = ":is(h1, h2, h3, h4, h5, h6)";
 
@@ -284,7 +289,7 @@ const lxb_char_t selector3[] = "input:is([type='text'], [type='email'], [type='p
 
 ### Using :not() for Exclusion
 
-```c
+```C
 /* All paragraphs except those with class 'exclude' */
 const lxb_char_t selector1[] = "p:not(.exclude)";
 
@@ -300,7 +305,7 @@ const lxb_char_t selector4[] = "a:not([href^='http'])";
 
 ### Using :has() for Parent Selection
 
-```c
+```C
 /* Find articles that contain an image */
 const lxb_char_t selector1[] = "article:has(img)";
 
@@ -316,7 +321,7 @@ const lxb_char_t selector4[] = "li:not(:has(a))";
 
 ### Attribute Selectors with Case Sensitivity
 
-```c
+```C
 /* Case-insensitive attribute match */
 const lxb_char_t selector1[] = "[title*='hello' i]";
 
@@ -329,7 +334,7 @@ const lxb_char_t selector3[] = "[class*='test' i]";
 
 ### Complex nth-child Patterns
 
-```c
+```C
 /* Every 3rd element starting from the 2nd: 2, 5, 8, 11... */
 const lxb_char_t selector1[] = "li:nth-child(3n+2)";
 
@@ -348,7 +353,7 @@ const lxb_char_t selector5[] = "div:nth-child(4n+1)";
 
 ### Combining Multiple Techniques
 
-```c
+```C
 /* Find divs with specific class that contain images but not links */
 const lxb_char_t selector2[] = "div.gallery:has(img):not(:has(a))";
 
@@ -361,7 +366,7 @@ const lxb_char_t selector4[] = "main :is(h1, h2, h3, h4, h5, h6):has(+ p)";
 
 ### Custom Lexbor Selector
 
-```c
+```C
 /* Find elements containing specific text (non-standard) */
 const lxb_char_t selector1[] = "div:-lexbor-contains('search text')";
 
@@ -376,6 +381,10 @@ const lxb_char_t selector3[] = ".content p:-lexbor-contains('TODO'):not(.done)";
 
 You can customize the search behavior by setting options using `lxb_selectors_opt_set()`. This allows you to control how the selector engine processes nodes and handles matches.
 
+### Location
+
+Search options and the `lxb_selectors_find` function are declared in `source/lexbor/selectors/selectors.h`.
+
 ### Available Options
 
 #### `LXB_SELECTORS_OPT_DEFAULT`
@@ -383,7 +392,7 @@ Default behavior:
 - Root node does **not** participate in the search (only its children)
 - If a node matches multiple selectors, callback is triggered for **each match**
 
-```c
+```C
 lxb_selectors_opt_set(selectors, LXB_SELECTORS_OPT_DEFAULT);
 ```
 
@@ -394,7 +403,7 @@ By default, when you call `lxb_selectors_find(selectors, root, list, callback, c
 
 This option makes the root node participate in the search, which is useful when you want to check if the root node itself matches any selectors.
 
-```c
+```C
 lxb_selectors_opt_set(selectors, LXB_SELECTORS_OPT_MATCH_ROOT);
 ```
 
@@ -405,7 +414,7 @@ By default, if a node matches multiple selectors in the list, the callback is tr
 
 This option ensures the callback is called only **once per node**, even if it matches multiple selectors.
 
-```c
+```C
 lxb_selectors_opt_set(selectors, LXB_SELECTORS_OPT_MATCH_FIRST);
 ```
 
@@ -413,7 +422,7 @@ lxb_selectors_opt_set(selectors, LXB_SELECTORS_OPT_MATCH_FIRST);
 
 You can combine options using the bitwise OR operator (`|`):
 
-```c
+```C
 /* Include root node AND stop after first match */
 lxb_selectors_opt_set(selectors,
                       LXB_SELECTORS_OPT_MATCH_ROOT | LXB_SELECTORS_OPT_MATCH_FIRST);
@@ -421,11 +430,12 @@ lxb_selectors_opt_set(selectors,
 
 ### Complete Example
 
-```c
+```C
 #include <lexbor/html/html.h>
 #include <lexbor/css/css.h>
 #include <lexbor/selectors/selectors.h>
 
+/* Callback type: lxb_selectors_cb_f */
 lxb_status_t
 callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t spec, void *ctx)
 {
@@ -475,11 +485,11 @@ int main(void)
     lxb_css_parser_destroy(parser, true);
     lxb_html_document_destroy(document);
 
-    return 0;
+    return EXIT_SUCCESS;
 }
 ```
 
-Output:
+**Output:**
 ```
 Found: div
 ```
@@ -488,6 +498,10 @@ Found: div
 
 Specificity is a weight that determines which CSS rule is applied when multiple selectors match the same element. The selector with the highest specificity wins.
 
+### Location
+
+Specificity types and accessor macros are declared in `source/lexbor/css/selectors/selector.h`.
+
 ### How Specificity is Calculated
 
 Specificity is calculated as a three-component value `(A, B, C)`:
@@ -528,20 +542,21 @@ Specificity is compared component by component from left to right. The selector
 
 #### `:is()` and `:has()`
 Take the specificity of the **most specific selector** in their argument list:
-```c
+```C
 /* Specificity of #header (1, 0, 0) */
 const lxb_char_t sel1[] = ":is(#header, .main, div)";
+```
 
 #### `:where()`
 Always has **zero specificity** (0, 0, 0), regardless of its arguments:
-```c
+```C
 /* Specificity is (0, 0, 1) - only 'a' counts */
 const lxb_char_t sel[] = ":where(#header, .main) a";
 ```
 
 #### `:not()`
 The negation itself adds nothing, but its argument counts:
-```c
+```C
 /* Specificity is (0, 1, 1) - .exclude + p */
 const lxb_char_t sel[] = "p:not(.exclude)";
 ```
@@ -550,7 +565,7 @@ const lxb_char_t sel[] = "p:not(.exclude)";
 
 The `lxb_selectors_find` callback receives specificity for each matched element:
 
-```c
+```C
 lxb_status_t
 find_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t spec, void *ctx)
 {
diff --git a/source/modules/url.md b/source/modules/url.md
index b347799..74a9d78 100644
--- a/source/modules/url.md
+++ b/source/modules/url.md
@@ -8,71 +8,551 @@
 
 ## Overview
 
-The URL module implements [WHATWG URL Living Standard](https://url.spec.whatwg.org/) for parsing, manipulating, and serializing URLs with full Unicode and internationalization support.
-The module provides complete, specification-compliant URL parsing with IDNA (Internationalized Domain Names in Applications) and Punycode support.
+The URL module implements the [WHATWG URL Living Standard](https://url.spec.whatwg.org/) for parsing, manipulating, and serializing URLs. It provides full Unicode and internationalization support through IDNA (Internationalized Domain Names in Applications) and Punycode encoding via the [Unicode module](unicode.md).
 
 ## Key Features
 
-- **Specification Compliant** — follows WHATWG URL Living Standard
-- **Unicode Support** — handles international domain names with IDNA/Punycode
-- **Relative URL Resolution** — parse relative URLs against a base URL
-- **Component Access** — extract and modify individual URL components
-- **Flexible Serialization** — convert URLs back to strings with callback or string output
-- **URLSearchParams** — parse and manipulate query parameters
+- **WHATWG Compliant** — complete URL parsing per specification
+- **Relative Resolution** — resolve relative URLs against a base URL
+- **URL API** — modify individual components (scheme, host, port, path, query, fragment, credentials)
+- **Host Parsing** — domain names, opaque hosts, IPv4, IPv6
+- **Special Schemes** — `http`, `https`, `ws`, `wss`, `ftp`, `file`
+- **URLSearchParams** — query string parsing and manipulation
+- **Serialization** — callback-based and component-level output
+- **IDNA/Punycode** — international domain name support via [Unicode module](unicode.md)
 
 ## What's Inside
 
-- **URL Parser** — parse absolute and relative URLs with base URL support
-- **URL Serialization** — convert URL objects to strings
-- **URL Components** — access scheme, host, port, path, query, fragment
-- **URL API** — modify URL
-- **URLSearchParams** — parse and manipulate query strings
-- **IDNA Support** — international domain names with Punycode encoding
-- **Host Types** — domain, opaque, IPv4, IPv6, empty host types
-- **Memory Management** — efficient memory allocation and cleanup
+- **[Quick Start](#quick-start)** — minimal working example to parse a URL
+- **[URL Parser](#url-parser-lxb_url_parser_t)** — parser lifecycle and memory management
+- **[URL Structure](#url-structure-lxb_url_t)** — parsed URL components and accessors
+- **[Scheme Types](#scheme-types)** — special scheme enumeration
+- **[Host Types](#host-types)** — host type enumeration and tagged union
+- **[URL API](#url-api-setters)** — functions for modifying URL components
+- **[Serialization](#serialization)** — callback-based URL serialization
+- **[URLSearchParams](#urlsearchparams-lxb_url_search_params_t)** — query parameter manipulation
+- **[Examples](#examples)** — complete working programs
 
 ## Quick Start
 
-### Basic URL Parsing
+### Parsing a URL
 
 ```C
 #include <lexbor/url/url.h>
 
 int main(void)
 {
-    const lxb_char_t url_str[] = "https://example.com:8080/path?query=value#fragment";
+    lxb_status_t status;
+
+    static const lxb_char_t url_str[] = "https://example.com:8080/path?q=test#section";
 
     /* Create and initialize parser */
     lxb_url_parser_t *parser = lxb_url_parser_create();
-    if (parser == NULL) {
+    status = lxb_url_parser_init(parser, NULL);
+    if (status != LXB_STATUS_OK) {
+        lxb_url_parser_destroy(parser, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Parse URL */
+    lxb_url_t *url = lxb_url_parse(parser, NULL, url_str, sizeof(url_str) - 1);
+    if (url == NULL) {
+        lxb_url_parser_destroy(parser, true);
         return EXIT_FAILURE;
     }
 
-    lxb_status_t status = lxb_url_parser_init(parser, NULL);
+    /* Access components */
+    const lexbor_str_t *scheme = lxb_url_scheme(url);
+    printf("Scheme: %.*s\n", (int) scheme->length, scheme->data);
+
+    if (lxb_url_has_port(url)) {
+        printf("Port: %u\n", lxb_url_port(url));
+    }
+
+    const lexbor_str_t *path = lxb_url_path_str(url);
+    printf("Path: %.*s\n", (int) path->length, path->data);
+
+    /* Cleanup */
+    lxb_url_memory_destroy(url);
+    lxb_url_parser_destroy(parser, true);
+
+    return EXIT_SUCCESS;
+}
+```
+
+**Output:**
+```
+Scheme: https
+Port: 8080
+Path: /path
+```
+
+
+## URL Parser (`lxb_url_parser_t`)
+
+The URL parser creates URL objects from string input. Defined in `source/lexbor/url/url.h`.
+
+### Location
+
+Declared in `source/lexbor/url/url.h`.
+
+### Lifecycle
+
+```C
+lxb_url_parser_t *
+lxb_url_parser_create(void);
+
+lxb_status_t
+lxb_url_parser_init(lxb_url_parser_t *parser, lexbor_mraw_t *mraw);
+
+void
+lxb_url_parser_clean(lxb_url_parser_t *parser);
+
+lxb_url_parser_t *
+lxb_url_parser_destroy(lxb_url_parser_t *parser, bool destroy_self);
+```
+
+- `lxb_url_parser_init()`: The `mraw` parameter is a memory allocator for created URLs. If `NULL`, the parser creates its own. All URLs created by this parser share this allocator — destroying the allocator destroys all associated URLs.
+- `lxb_url_parser_clean()`: Resets parser state. **Must** be called between successive parse calls.
+- `lxb_url_parser_destroy()`: Destroys the parser but **does not** destroy the memory allocator or any created URLs. If `destroy_self` is `true`, frees the parser object itself.
+
+### Memory Management
+
+The parser and URLs share a `lexbor_mraw_t` memory allocator. Understanding the ownership model is important:
+
+```C
+/* Destroy the parser's memory allocator and ALL associated URLs */
+void
+lxb_url_parser_memory_destroy(lxb_url_parser_t *parser);
+
+/* Destroy a single URL */
+lxb_url_t *
+lxb_url_destroy(lxb_url_t *url);
+
+/* Destroy the memory allocator referenced by this URL (and ALL URLs sharing it) */
+void
+lxb_url_memory_destroy(lxb_url_t *url);
+
+/* Get/set the parser's memory allocator */
+lexbor_mraw_t *
+lxb_url_mraw(lxb_url_parser_t *parser);
+
+void
+lxb_url_mraw_set(lxb_url_parser_t *parser, lexbor_mraw_t *mraw);
+```
+
+- `lxb_url_destroy()`: Frees a single URL's internal data.
+- `lxb_url_memory_destroy()`: Destroys the `lexbor_mraw_t` allocator associated with the URL, which destroys **all** URLs that share that allocator. If the parser still references this allocator, you must assign a new one with `lxb_url_mraw_set()` before parsing again.
+- `lxb_url_parser_memory_destroy()`: Same as above, accessed through the parser.
+
+### Parsing
+
+```C
+lxb_url_t *
+lxb_url_parse(lxb_url_parser_t *parser, const lxb_url_t *base_url,
+              const lxb_char_t *data, size_t length);
+
+lxb_status_t
+lxb_url_parse_basic(lxb_url_parser_t *parser, lxb_url_t *url,
+                    const lxb_url_t *base_url,
+                    const lxb_char_t *data, size_t length,
+                    lxb_url_state_t override_state, lxb_encoding_t encoding);
+```
+
+- `lxb_url_parse()`: Parses a URL string and returns a new `lxb_url_t` object. Pass a `base_url` to resolve relative URLs, or `NULL` for absolute URLs. Returns `NULL` on failure.
+- `lxb_url_parse_basic()`: Lower-level parser. Can parse into an existing `lxb_url_t` (pass `NULL` to create a new one). Supports overriding the start state and encoding. Use `LXB_URL_STATE__UNDEF` and `LXB_ENCODING_DEFAULT` for defaults. The resulting URL is retrieved with `lxb_url_get(parser)`.
+
+
+## URL Structure (`lxb_url_t`)
+
+A parsed URL. Defined in `source/lexbor/url/url.h`.
+
+### Location
+
+Defined in `source/lexbor/url/url.h`.
+
+```C
+typedef struct {
+    lxb_url_scheme_t   scheme;
+    lxb_url_host_t     host;
+    lexbor_str_t       username;
+    lexbor_str_t       password;
+    uint16_t           port;
+    bool               has_port;
+    lxb_url_path_t     path;
+    lexbor_str_t       query;
+    lexbor_str_t       fragment;
+    lexbor_mraw_t      *mraw;
+} lxb_url_t;
+```
+
+### Component Accessors
+
+Inline functions for reading URL components:
+
+```C
+const lexbor_str_t *   lxb_url_scheme(const lxb_url_t *url);
+const lexbor_str_t *   lxb_url_username(const lxb_url_t *url);
+const lexbor_str_t *   lxb_url_password(const lxb_url_t *url);
+const lxb_url_host_t * lxb_url_host(const lxb_url_t *url);
+uint16_t               lxb_url_port(const lxb_url_t *url);
+bool                   lxb_url_has_port(const lxb_url_t *url);
+const lxb_url_path_t * lxb_url_path(const lxb_url_t *url);
+const lexbor_str_t *   lxb_url_path_str(const lxb_url_t *url);
+const lexbor_str_t *   lxb_url_query(const lxb_url_t *url);
+const lexbor_str_t *   lxb_url_fragment(const lxb_url_t *url);
+```
+
+String components (`lexbor_str_t`) have `data` and `length` fields. A component is absent when its `data` is `NULL`.
+
+### Cloning
+
+```C
+lxb_url_t *
+lxb_url_clone(lexbor_mraw_t *mraw, const lxb_url_t *url);
+```
+
+Creates a deep copy of a URL. Use `url->mraw` to clone into the same memory pool, or pass a different allocator.
+
+
+## Scheme Types
+
+### Location
+
+Defined in `source/lexbor/url/url.h`.
+
+```C
+typedef enum {
+    LXB_URL_SCHEMEL_TYPE__UNDEF   = 0x00,
+    LXB_URL_SCHEMEL_TYPE__UNKNOWN = 0x01,
+    LXB_URL_SCHEMEL_TYPE_HTTP     = 0x02,
+    LXB_URL_SCHEMEL_TYPE_HTTPS    = 0x03,
+    LXB_URL_SCHEMEL_TYPE_WS       = 0x04,
+    LXB_URL_SCHEMEL_TYPE_WSS      = 0x05,
+    LXB_URL_SCHEMEL_TYPE_FTP      = 0x06,
+    LXB_URL_SCHEMEL_TYPE_FILE     = 0x07
+} lxb_url_scheme_type_t;
+```
+
+The scheme is stored in `lxb_url_scheme_t` which contains both the string `name` and a `type` field for fast comparisons. Special schemes (`http`, `https`, `ws`, `wss`, `ftp`, `file`) have known types; all others are `_UNKNOWN`.
+
+
+## Host Types
+
+### Location
+
+Defined in `source/lexbor/url/url.h`.
+
+```C
+typedef enum {
+    LXB_URL_HOST_TYPE__UNDEF = 0x00,
+    LXB_URL_HOST_TYPE_DOMAIN = 0x01,
+    LXB_URL_HOST_TYPE_OPAQUE = 0x02,
+    LXB_URL_HOST_TYPE_IPV4   = 0x03,
+    LXB_URL_HOST_TYPE_IPV6   = 0x04,
+    LXB_URL_HOST_TYPE_EMPTY  = 0x05
+} lxb_url_host_type_t;
+```
+
+The host is stored in `lxb_url_host_t` with a tagged union:
+
+```C
+typedef struct {
+    lxb_url_host_type_t type;
+    union {
+        uint16_t     ipv6[8];   /* 8 x 16-bit pieces */
+        uint32_t     ipv4;      /* 32-bit address    */
+        lexbor_str_t opaque;    /* opaque host string */
+        lexbor_str_t domain;    /* domain string      */
+    } u;
+} lxb_url_host_t;
+```
+
+Check `host->type` before accessing the union.
+
+
+## URL API (Setters)
+
+Functions for modifying URL components per the [URL API specification](https://url.spec.whatwg.org/#api). The `parser` parameter is optional — pass it to collect parsing logs, or `NULL` to skip logging.
+
+### Location
+
+URL API functions are declared in `source/lexbor/url/url.h`.
+
+```C
+lxb_status_t lxb_url_api_href_set(lxb_url_t *url, lxb_url_parser_t *parser,
+                                   const lxb_char_t *href, size_t length);
+
+lxb_status_t lxb_url_api_protocol_set(lxb_url_t *url, lxb_url_parser_t *parser,
+                                       const lxb_char_t *protocol, size_t length);
+
+lxb_status_t lxb_url_api_username_set(lxb_url_t *url,
+                                       const lxb_char_t *username, size_t length);
+
+lxb_status_t lxb_url_api_password_set(lxb_url_t *url,
+                                       const lxb_char_t *password, size_t length);
+
+lxb_status_t lxb_url_api_host_set(lxb_url_t *url, lxb_url_parser_t *parser,
+                                   const lxb_char_t *host, size_t length);
+
+lxb_status_t lxb_url_api_hostname_set(lxb_url_t *url, lxb_url_parser_t *parser,
+                                       const lxb_char_t *hostname, size_t length);
+
+lxb_status_t lxb_url_api_port_set(lxb_url_t *url, lxb_url_parser_t *parser,
+                                   const lxb_char_t *port, size_t length);
+
+lxb_status_t lxb_url_api_pathname_set(lxb_url_t *url, lxb_url_parser_t *parser,
+                                       const lxb_char_t *pathname, size_t length);
+
+lxb_status_t lxb_url_api_search_set(lxb_url_t *url, lxb_url_parser_t *parser,
+                                     const lxb_char_t *search, size_t length);
+
+lxb_status_t lxb_url_api_hash_set(lxb_url_t *url, lxb_url_parser_t *parser,
+                                   const lxb_char_t *hash, size_t length);
+```
+
+- `lxb_url_api_host_set()`: Sets both hostname and port (e.g., `"example.com:8080"`).
+- `lxb_url_api_hostname_set()`: Sets hostname only.
+- All functions accept `NULL` as the data pointer to clear the component.
+
+
+## Serialization
+
+Callback-based serialization for the full URL or individual components. The callback may be invoked multiple times per call.
+
+### Location
+
+Serialization functions are declared in `source/lexbor/url/url.h`.
+
+```C
+lxb_status_t
+lxb_url_serialize(const lxb_url_t *url, lexbor_serialize_cb_f cb, void *ctx,
+                  bool exclude_fragment);
+```
+
+Pass `exclude_fragment` as `true` to omit the fragment from output.
+
+### Component Serialization
+
+```C
+lxb_status_t lxb_url_serialize_scheme(const lxb_url_t *url,
+                                       lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_username(const lxb_url_t *url,
+                                         lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_password(const lxb_url_t *url,
+                                         lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_host(const lxb_url_host_t *host,
+                                     lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_port(const lxb_url_t *url,
+                                     lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_path(const lxb_url_path_t *path,
+                                     lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_query(const lxb_url_t *url,
+                                      lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_fragment(const lxb_url_t *url,
+                                         lexbor_serialize_cb_f cb, void *ctx);
+```
+
+### Host Serialization Variants
+
+```C
+lxb_status_t lxb_url_serialize_host_unicode(lxb_unicode_idna_t *idna,
+                                             const lxb_url_host_t *host,
+                                             lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_host_ipv4(uint32_t ipv4,
+                                          lexbor_serialize_cb_f cb, void *ctx);
+lxb_status_t lxb_url_serialize_host_ipv6(const uint16_t *ipv6,
+                                          lexbor_serialize_cb_f cb, void *ctx);
+```
+
+There is also `lxb_url_serialize_idna()` which serializes the full URL with Unicode domain display using an IDNA context.
+
+
+## URLSearchParams (`lxb_url_search_params_t`)
+
+Implements the [URLSearchParams](https://url.spec.whatwg.org/#interface-urlsearchparams) interface for parsing and manipulating query parameters.
+
+### Location
+
+Declared in `source/lexbor/url/url.h`.
+
+### Structure
+
+```C
+typedef struct lxb_url_search_entry {
+    lexbor_str_t           name;
+    lexbor_str_t           value;
+    lxb_url_search_entry_t *next;
+    lxb_url_search_entry_t *prev;
+} lxb_url_search_entry_t;
+
+typedef struct {
+    lxb_url_search_entry_t *first;
+    lxb_url_search_entry_t *last;
+    lexbor_mraw_t          *mraw;
+    size_t                 length;
+} lxb_url_search_params_t;
+```
+
+Parameters are stored as a doubly-linked list of name/value entries.
+
+### Lifecycle
+
+```C
+lxb_url_search_params_t *
+lxb_url_search_params_init(lexbor_mraw_t *mraw,
+                           const lxb_char_t *params, size_t length);
+
+lxb_url_search_params_t *
+lxb_url_search_params_destroy(lxb_url_search_params_t *search_params);
+```
+
+- `lxb_url_search_params_init()`: Creates and initializes from a query string (e.g., `"key1=val1&key2=val2"`). The `mraw` parameter is required and can be taken from a URL's `mraw` field. Pass `NULL`/`0` for `params`/`length` to create an empty set.
+
+### Operations
+
+```C
+/* Append a name/value pair (duplicates allowed) */
+lxb_url_search_entry_t *
+lxb_url_search_params_append(lxb_url_search_params_t *sp,
+                             const lxb_char_t *name, size_t name_length,
+                             const lxb_char_t *value, size_t value_length);
+
+/* Delete entries by name; if value is non-NULL, only matching name+value pairs */
+void
+lxb_url_search_params_delete(lxb_url_search_params_t *sp,
+                             const lxb_char_t *name, size_t name_length,
+                             const lxb_char_t *value, size_t value_length);
+
+/* Get the first value for a name */
+lexbor_str_t *
+lxb_url_search_params_get(lxb_url_search_params_t *sp,
+                          const lxb_char_t *name, size_t length);
+
+/* Get the first entry for a name */
+lxb_url_search_entry_t *
+lxb_url_search_params_get_entry(lxb_url_search_params_t *sp,
+                                const lxb_char_t *name, size_t length);
+
+/* Get all values for a name into a buffer; returns number found */
+size_t
+lxb_url_search_params_get_all(lxb_url_search_params_t *sp,
+                              const lxb_char_t *name, size_t length,
+                              lexbor_str_t **out_buf, size_t out_size);
+
+/* Count values for a name (useful for sizing the buffer before get_all) */
+size_t
+lxb_url_search_params_get_count(lxb_url_search_params_t *sp,
+                                const lxb_char_t *name, size_t length);
+
+/* Check if a name (and optionally value) exists */
+bool
+lxb_url_search_params_has(lxb_url_search_params_t *sp,
+                          const lxb_char_t *name, size_t name_length,
+                          const lxb_char_t *value, size_t value_length);
+
+/* Set a name to a single value (removes all existing entries with that name) */
+lxb_url_search_entry_t *
+lxb_url_search_params_set(lxb_url_search_params_t *sp,
+                          const lxb_char_t *name, size_t name_length,
+                          const lxb_char_t *value, size_t value_length);
+
+/* Sort entries alphabetically by name */
+void
+lxb_url_search_params_sort(lxb_url_search_params_t *sp);
+
+/* Serialize to application/x-www-form-urlencoded format */
+lxb_status_t
+lxb_url_search_params_serialize(lxb_url_search_params_t *sp,
+                                lexbor_callback_f cb, void *ctx);
+```
+
+### Iteration
+
+```C
+/* Find matching entry starting from a given position */
+lxb_url_search_entry_t *
+lxb_url_search_params_match_entry(lxb_url_search_params_t *sp,
+                                  const lxb_char_t *name, size_t name_length,
+                                  const lxb_char_t *value, size_t value_length,
+                                  lxb_url_search_entry_t *entry);
+
+/* Iterate all matching entries with a callback */
+void
+lxb_url_search_params_match(lxb_url_search_params_t *sp,
+                            const lxb_char_t *name, size_t name_length,
+                            const lxb_char_t *value, size_t value_length,
+                            lxb_url_search_params_match_f cb, void *ctx);
+```
+
+The callback type is:
+
+```C
+typedef lexbor_action_t
+(*lxb_url_search_params_match_f)(lxb_url_search_params_t *sp,
+                                 lxb_url_search_entry_t *entry, void *ctx);
+```
+
+Return `LEXBOR_ACTION_OK` to continue iteration, `LEXBOR_ACTION_STOP` to stop.
+
+
+## Examples
+
+### Parsing and Accessing Components
+
+```C
+#include <lexbor/url/url.h>
+
+int
+main(void)
+{
+    lxb_status_t status;
+    lxb_url_parser_t *parser;
+    lxb_url_t *url;
+
+    static const lxb_char_t url_str[] =
+        "https://user:pass@example.com:8080/path/to/page?q=test#section";
+
+    /* Create and initialize parser */
+    parser = lxb_url_parser_create();
+    status = lxb_url_parser_init(parser, NULL);
     if (status != LXB_STATUS_OK) {
         lxb_url_parser_destroy(parser, true);
         return EXIT_FAILURE;
     }
 
     /* Parse URL */
-    lxb_url_t *url = lxb_url_parse(parser, NULL, url_str, sizeof(url_str) - 1);
+    url = lxb_url_parse(parser, NULL, url_str, sizeof(url_str) - 1);
     if (url == NULL) {
         lxb_url_parser_destroy(parser, true);
         return EXIT_FAILURE;
     }
 
     /* Access components */
-    printf("Scheme: %.*s\n",
-           (int) lxb_url_scheme(url)->length,
-           lxb_url_scheme(url)->data);
+    const lexbor_str_t *scheme = lxb_url_scheme(url);
+    printf("Scheme: %.*s\n", (int) scheme->length, scheme->data);
 
-    printf("Port: %u\n", lxb_url_port(url));
+    const lexbor_str_t *user = lxb_url_username(url);
+    printf("Username: %.*s\n", (int) user->length, user->data);
 
-    printf("Path: %.*s\n",
-           (int) lxb_url_path_str(url)->length,
-           lxb_url_path_str(url)->data);
+    if (lxb_url_has_port(url)) {
+        printf("Port: %u\n", lxb_url_port(url));
+    }
 
-    /* Cleanup */
+    const lexbor_str_t *path = lxb_url_path_str(url);
+    printf("Path: %.*s\n", (int) path->length, path->data);
+
+    const lexbor_str_t *query = lxb_url_query(url);
+    if (query->data != NULL) {
+        printf("Query: %.*s\n", (int) query->length, query->data);
+    }
+
+    const lexbor_str_t *fragment = lxb_url_fragment(url);
+    if (fragment->data != NULL) {
+        printf("Fragment: %.*s\n", (int) fragment->length, fragment->data);
+    }
+
+    /* Cleanup: destroy all URLs and the parser */
     lxb_url_memory_destroy(url);
     lxb_url_parser_destroy(parser, true);
 
@@ -80,5 +560,124 @@ int main(void)
 }
 ```
 
+### Relative URL Resolution
+
+```C
+#include <lexbor/url/url.h>
+
+static lxb_status_t
+print_cb(const lxb_char_t *data, size_t len, void *ctx)
+{
+    printf("%.*s", (int) len, data);
+    return LXB_STATUS_OK;
+}
+
+int
+main(void)
+{
+    lxb_status_t status;
+    lxb_url_parser_t *parser;
+    lxb_url_t *base, *relative;
+
+    static const lxb_char_t base_str[] = "https://example.com/docs/guide/";
+    static const lxb_char_t rel_str[] = "../api/reference.html?v=2";
+
+    parser = lxb_url_parser_create();
+    status = lxb_url_parser_init(parser, NULL);
+    if (status != LXB_STATUS_OK) {
+        lxb_url_parser_destroy(parser, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Parse the base URL */
+    base = lxb_url_parse(parser, NULL, base_str, sizeof(base_str) - 1);
+    if (base == NULL) {
+        lxb_url_parser_destroy(parser, true);
+        return EXIT_FAILURE;
+    }
+
+    lxb_url_parser_clean(parser);
+
+    /* Parse relative URL against the base */
+    relative = lxb_url_parse(parser, base, rel_str, sizeof(rel_str) - 1);
+    if (relative == NULL) {
+        lxb_url_memory_destroy(base);
+        lxb_url_parser_destroy(parser, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Serialize the resolved URL */
+    printf("Resolved: ");
+    lxb_url_serialize(relative, print_cb, NULL, false);
+    printf("\n");
+    /* Output: Resolved: https://example.com/api/reference.html?v=2 */
+
+    lxb_url_memory_destroy(base);
+    lxb_url_parser_destroy(parser, true);
+
+    return EXIT_SUCCESS;
+}
+```
+
+### URLSearchParams
+
+```C
+#include <lexbor/url/url.h>
+#include <lexbor/core/mraw.h>
+
+int
+main(void)
+{
+    lexbor_mraw_t *mraw;
+    lxb_url_search_params_t *sp;
+
+    /* Create a memory allocator */
+    mraw = lexbor_mraw_create();
+    if (lexbor_mraw_init(mraw, 256) != LXB_STATUS_OK) {
+        return EXIT_FAILURE;
+    }
+
+    /* Initialize from a query string */
+    static const lxb_char_t params[] = "lang=en&page=1&sort=name";
+    sp = lxb_url_search_params_init(mraw, params, sizeof(params) - 1);
+    if (sp == NULL) {
+        lexbor_mraw_destroy(mraw, true);
+        return EXIT_FAILURE;
+    }
+
+    /* Get a value */
+    lexbor_str_t *val = lxb_url_search_params_get(sp,
+        (const lxb_char_t *) "page", 4);
+    if (val != NULL) {
+        printf("page = %.*s\n", (int) val->length, val->data);
+    }
+
+    /* Set a value (replaces existing) */
+    lxb_url_search_params_set(sp,
+        (const lxb_char_t *) "page", 4,
+        (const lxb_char_t *) "2", 1);
+
+    /* Append a new parameter */
+    lxb_url_search_params_append(sp,
+        (const lxb_char_t *) "filter", 6,
+        (const lxb_char_t *) "active", 6);
+
+    /* Check existence */
+    bool has = lxb_url_search_params_has(sp,
+        (const lxb_char_t *) "filter", 6, NULL, 0);
+    printf("has 'filter': %s\n", has ? "true" : "false");
 
-*(Documentation is currently being developed, details will be available here soon.)*
+    /* Delete a parameter */
+    lxb_url_search_params_delete(sp,
+        (const lxb_char_t *) "sort", 4, NULL, 0);
+
+    /* Sort alphabetically */
+    lxb_url_search_params_sort(sp);
+
+    /* Cleanup */
+    lxb_url_search_params_destroy(sp);
+    lexbor_mraw_destroy(mraw, true);
+
+    return EXIT_SUCCESS;
+}
+```
diff --git a/source/roadmap.md b/source/roadmap.md
index 8898096..51e5248 100644
--- a/source/roadmap.md
+++ b/source/roadmap.md
@@ -54,15 +54,15 @@ the order of their implementation.
 16. [Background](https://drafts.csswg.org/css-backgrounds-3/): ![In Progress][progress]
 17. [Content](https://drafts.csswg.org/css-content-3/)
 18. [Overflow](https://drafts.csswg.org/css-overflow-3/): ![In Progress][progress]
-19. [Media Queries](https://drafts.csswg.org/mediaqueries-4/)
+19. [Media Queries](https://drafts.csswg.org/mediaqueries-4/): ![In Progress][progress]
 20. [Page](https://drafts.csswg.org/css-page-3/)
 21. [Variables](https://drafts.csswg.org/css-variables-1/)
 
 
 ## Fonts, OpenType
 
-1. [Font/OpenType](https://docs.microsoft.com/ru-ru/typography/opentype/spec/)<br>
-   1.1. [Parsing OpenType font files](https://docs.microsoft.com/ru-ru/typography/opentype/spec/otff)<br>
+1. [Font/OpenType](https://learn.microsoft.com/en-us/typography/opentype/spec/)<br>
+   1.1. [Parsing OpenType font files](https://learn.microsoft.com/en-us/typography/opentype/spec/otff)<br>
    1.2. Calculating font metrics for glyphs in HTML layout: `baseline`,
         `ascender`, `descender`, `line-gap`, `x-height`, `cap-height`,
         `width`, `height`
@@ -83,9 +83,9 @@ the order of their implementation.
 
 ## Unicode
 
-1. [http://www.unicode.org/](http://www.unicode.org/): ![Done][done]<br>
+1. [https://www.unicode.org/](https://www.unicode.org/): ![Done][done]<br>
    1.1. [Normalization forms](https://www.unicode.org/reports/tr15/): ![Done][done]<br>
-   1.2. [Unicode IDNA Compatibility Processing](http://www.unicode.org/reports/tr46/): ![Done][done]
+   1.2. [Unicode IDNA Compatibility Processing](https://www.unicode.org/reports/tr46/): ![Done][done]
 
 
 ## Layout