## Rendering Process

The `RouteManager` class (`/foldsite/src/routes/routes.py`) and `render_page` function (`/foldsite/src/rendering/renderer.py`) are central to the rendering process.

### How Foldsite Determines File Types

The `determine_type` function (in `renderer.py`) is crucial for figuring out how to handle a given file or directory. It examines file extensions and directory contents to classify files into broad categories (defined in `GENERIC_FILE_MAPPING` in `/foldsite/src/rendering/__init__.py`):

*   **`document`**:  Files with extensions like `.md`, `.txt`, and `.html`.
*   **`image`**: Files with extensions like `.png`, `.jpg`, `.jpeg`, `.gif`, and `.svg`.
*   **`directory`**: Directories.  If a directory contains files, the most common file extension within that directory is used to infer the directory's "type".
*   **`other`**: Files that don't match any of the above categories.
* **`multimedia`**: This is a combination that contains `image`.

### Template Search

When a request comes in, Foldsite searches for an appropriate template in the `templates` directory.  The search logic is implemented in `render_page` and follows a specific order, prioritizing more specific templates:

1.  **Exact Path Match:** If a template exists with the exact same path relative to the `templates` directory as the requested content file (but with a `.html` extension), it's used.  For example, if the request is for `/about/team.md`, and a template exists at `templates/about/team.md.html`, that template will be used.

2.  **Folder-Specific Template:** If the requested path is a directory, Foldsite looks for a `__folder.html` template within that directory.  For example, if the request is for `/blog/`, and `templates/blog/__folder.html` exists, it will be used.

3.  **Type and Extension-Specific Templates:** Foldsite searches for templates named `__{type}.{extension}.html` within the requested directory and its parent directories, moving upwards.  For instance, if requesting `/blog/post1.md`, it would look for:
    *   `templates/blog/__file.md.html`
    *   `templates/__file.md.html`

4.  **Type and Category-Specific Templates:**  Similar to the above, but searches for `__{type}.{category}.html`. If requesting an image at `/images/logo.png`, it looks for:

    *   `templates/images/__file.image.html`
    *   `templates/__file.image.html`

5.  **Base Template:** Finally, if no other template is found, `templates/base.html` is used as a fallback.  This template *must* exist; otherwise, an exception is raised.

### Style Search

CSS styles are searched similarly to templates, prioritizing specificity:

1.  **Exact Path Match:** A CSS file with the exact same path as the requested content file (relative to the `styles` directory) is used.  For example, `/about/team.md` would look for `styles/about/team.md.css`.

2.  **Type and Extension-Specific Styles:**  Searches for `__{type}.{extension}.css` in the requested directory and its parent directories.  For example, `/blog/post1.md` would look for:

    *   `styles/blog/__file.md.css`
    *   `styles/__file.md.css`

3.  **Type and Category-Specific Styles:** Similar to the above, but searches for `__{type}.{category}.css`.

    *   `styles/images/__file.image.css`
    *   `styles/__file.image.css`

4.  **Base Style:**  `styles/base.css` is always included.

The discovered styles are added to the `styles` variable, which is passed to the Jinja2 template. The order ensures that more specific styles override general ones.

### Error Handling

The `render_error_page` function (in `renderer.py`) handles errors.  If a requested resource is not found (404 error) or if an exception occurs during processing, this function is called. It looks for a template named `__error.html` in the `templates` directory.  If found, it's used to render the error page; otherwise, a default error page is generated.  The error code, message, and description are passed to the template.