Please address the comments from this code review:
## Overall Comments
- Consider providing a fallback import for tomllib (e.g. tomli) or explicitly pinning Python 3.11+ in your requirements to avoid runtime import errors on older versions.
- Since `_load_constants` is called every time a new `Constants` is instantiated, consider caching the loaded TOML data (e.g. as a class variable) to avoid redundant disk reads.
- The unit tests assert directly against the live TOML file and can become brittle when constants change—consider mocking the file load or using a dedicated test fixture to isolate test data from production constants.

## Individual Comments

### Comment 1
<location> `tux/utils/constants.py:7` </location>
<code_context>
+from tux.utils.config import workspace_root
+
+
+def _load_constants() -> dict[str, Any]:
+    """Load constants from the TOML configuration file."""
+    constants_path = workspace_root / "assets" / "data" / "constants.toml"
</code_context>

<issue_to_address>
Consider error handling for missing or malformed TOML files.

If the TOML file is missing or malformed, the function will raise an unhandled exception. Adding error handling could improve user feedback or allow for fallback behavior.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
def _load_constants() -> dict[str, Any]:
    """Load constants from the TOML configuration file."""
    constants_path = workspace_root / "assets" / "data" / "constants.toml"
    with constants_path.open("rb") as f:
        return tomllib.load(f)
=======
def _load_constants() -> dict[str, Any]:
    """Load constants from the TOML configuration file.

    Returns an empty dict if the file is missing or malformed.
    """
    import logging

    constants_path = workspace_root / "assets" / "data" / "constants.toml"
    try:
        with constants_path.open("rb") as f:
            return tomllib.load(f)
    except FileNotFoundError:
        logging.error(f"Constants TOML file not found at {constants_path}")
        return {}
    except tomllib.TOMLDecodeError as e:
        logging.error(f"Malformed TOML in constants file at {constants_path}: {e}")
        return {}
>>>>>>> REPLACE

</suggested_fix>

### Comment 2
<location> `tests/unit/tux/utils/test_constants.py:44` </location>
<code_context>
-        assert Constants.SNIPPET_ALLOWED_CHARS_REGEX == r"^[a-zA-Z0-9-]+$"
-        assert Constants.SNIPPET_PAGINATION_LIMIT == 10
+        assert CONST.SNIPPET_MAX_NAME_LENGTH == 20
+        assert CONST.SNIPPET_ALLOWED_CHARS_REGEX == "^[a-zA-Z0-9-]+$"
+        assert CONST.SNIPPET_PAGINATION_LIMIT == 10

     def test_afk_constants(self):
</code_context>

<issue_to_address>
Test coverage for regex pattern usage is missing.

Please add tests that use the regex to check both valid and invalid snippet names, ensuring the pattern works as expected.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
    def test_snippet_constants(self):
        """Test snippet-related constants."""
        assert CONST.SNIPPET_MAX_NAME_LENGTH == 20
        assert CONST.SNIPPET_ALLOWED_CHARS_REGEX == "^[a-zA-Z0-9-]+$"
        assert CONST.SNIPPET_PAGINATION_LIMIT == 10
=======
    def test_snippet_constants(self):
        """Test snippet-related constants."""
        assert CONST.SNIPPET_MAX_NAME_LENGTH == 20
        assert CONST.SNIPPET_ALLOWED_CHARS_REGEX == "^[a-zA-Z0-9-]+$"
        assert CONST.SNIPPET_PAGINATION_LIMIT == 10

    def test_snippet_name_regex(self):
        """Test that the snippet name regex matches valid names and rejects invalid ones."""
        import re

        pattern = re.compile(CONST.SNIPPET_ALLOWED_CHARS_REGEX)

        valid_names = [
            "snippet1",
            "Snippet-2",
            "A1B2C3",
            "test-123",
            "abcDEF-456"
        ]
        invalid_names = [
            "snippet_1",   # underscore not allowed
            "snippet 1",   # space not allowed
            "snippet!",    # exclamation not allowed
            "snippet@",    # special char not allowed
            "snippet.name" # dot not allowed
        ]

        for name in valid_names:
            assert pattern.fullmatch(name), f"Valid name did not match: {name}"

        for name in invalid_names:
            assert not pattern.fullmatch(name), f"Invalid name matched: {name}"
>>>>>>> REPLACE

</suggested_fix>

### Comment 3
<location> `tux/utils/constants.py:15` </location>
<code_context>
-    # Bookmark constants
-    ADD_BOOKMARK = "🔖"
-    REMOVE_BOOKMARK = "🗑️"
+    def __init__(self) -> None:
+        data = _load_constants()
+
</code_context>

<issue_to_address>
Consider using a flattening helper to automatically assign all constants as class attributes, reducing repetitive assignment code.

You can collapse almost all of the repetitive `self.FOO = ...` lines into a small “flattening” helper.  Because `tomllib` already gives you real `int` and `str` types you can skip all of the `int(...)` and `str(...)` calls, and then automatically turn every nested key into a `UPPER_SNAKE` attribute on your class.  

For example, add a small utility:

```python
def _flatten_constants(data: dict[str, Any]) -> dict[str, Any]:
    """Turn e.g. data['embed_limits']['max_name_length'] into {'EMBED_MAX_NAME_LENGTH': 256}."""
    out: dict[str, Any] = {}
    for section, mapping in data.items():
        # drop common suffixes and singularize
        prefix = (
            section
            .removesuffix("_limits")
            .removesuffix("_config")
            .removesuffix("s")
            .upper()
        )
        for key, val in mapping.items():
            name = f"{prefix}_{key}".upper()
            out[name] = val
    return out
```

Then your `Constants` class can become:

```python
class Constants:
    def __init__(self):
        data = _load_constants()
        flats = _flatten_constants(data)

        # bulk‐assign everything
        for attr, val in flats.items():
            setattr(self, attr, val)

CONST = Constants()
```

This preserves your existing attribute names, removes dozens of `self.X = int(...)` lines, and will automatically pick up any new keys you add to the TOML later.
</issue_to_address>