ouro-tui-themes 0.3.6__tar.gz

ouro_tui_themes-0.3.6/.gitignore

@@ -0,0 +1,38 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.egg-info/
+dist/
+dist-linux/
+build/
+
+# Virtual environments
+.venv/
+.venv-*/
+venv/
+
+# Testing / coverage
+.coverage
+.coverage.*
+.pytest_cache/
+htmlcov/
+
+# Tool caches
+.ruff_cache/
+.mypy_cache/
+
+# IDE
+.idea/
+.vscode/
+.claude/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# User
+.ouro
+.ouro-dev

ouro_tui_themes-0.3.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OURO contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ouro_tui_themes-0.3.6/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.5
+Name: ouro-tui-themes
+Version: 0.3.6
+Summary: Optional OURO welcome styles and shared dot-matrix rendering engine.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: numpy<3,>=2.3.3
+Requires-Dist: ouro-agent==0.3.6
+Description-Content-Type: text/markdown
+
+# OURO TUI themes
+
+Install the complete optional welcome extension in the OURO environment:
+
+```sh
+pip install "ouro-agent[themes]"
+```
+
+This distribution contains both the shared `ouro_tui_themes.dot_matrix` engine and
+the official `ouro_tui_themes.styles` collection. The engine owns numerical fields,
+terminal rasterization and widget scheduling; styles own artwork and page composition.
+The engine does not depend on style implementations or welcome-page contracts.
+
+OURO's core provides the welcome API, persistent input surface, shared information
+components and the `basic` fallback page. It runs without this distribution or NumPy.
+The application loads style metadata from the installed matching release and imports
+renderers only when selected. Missing extensions or unavailable dependencies preserve
+the saved selection while displaying `basic`; restarting after installation restores it.
+
+Core and extension releases use the same version and are built together from the OURO
+workspace with `uv build --all-packages`. Both wheels must be available when installing
+the `themes` extra. The extension declares its compatible core version and NumPy requirement.

ouro_tui_themes-0.3.6/README.md

@@ -0,0 +1,22 @@
+# OURO TUI themes
+
+Install the complete optional welcome extension in the OURO environment:
+
+```sh
+pip install "ouro-agent[themes]"
+```
+
+This distribution contains both the shared `ouro_tui_themes.dot_matrix` engine and
+the official `ouro_tui_themes.styles` collection. The engine owns numerical fields,
+terminal rasterization and widget scheduling; styles own artwork and page composition.
+The engine does not depend on style implementations or welcome-page contracts.
+
+OURO's core provides the welcome API, persistent input surface, shared information
+components and the `basic` fallback page. It runs without this distribution or NumPy.
+The application loads style metadata from the installed matching release and imports
+renderers only when selected. Missing extensions or unavailable dependencies preserve
+the saved selection while displaying `basic`; restarting after installation restores it.
+
+Core and extension releases use the same version and are built together from the OURO
+workspace with `uv build --all-packages`. Both wheels must be available when installing
+the `themes` extra. The extension declares its compatible core version and NumPy requirement.

ouro_tui_themes-0.3.6/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "ouro-tui-themes"
+version = "0.3.6"
+description = "Optional OURO welcome styles and shared dot-matrix rendering engine."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+dependencies = [
+    "ouro-agent==0.3.6",
+    "numpy>=2.3.3,<3",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ouro_tui_themes"]

ouro_tui_themes-0.3.6/src/ouro_tui_themes/__init__.py

@@ -0,0 +1 @@
+"""Optional welcome extensions, installed together through ouro-agent[themes]."""

ouro_tui_themes-0.3.6/src/ouro_tui_themes/dot_matrix/__init__.py

@@ -0,0 +1 @@
+"""Shared numerical and terminal primitives used by the particle themes."""

ouro_tui_themes-0.3.6/src/ouro_tui_themes/dot_matrix/field.py

@@ -0,0 +1,131 @@
+"""Shared numerical engine used by the bundled particle themes.
+
+Grid, sampler contract, array operations and the default backend live together.
+No UI objects, terminal geometry, theme registry or scheduling enter this module.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from math import exp
+from typing import Protocol
+
+import numpy as np
+from numpy.typing import NDArray
+
+type Field = NDArray[np.float64]
+type Radiance = tuple[Field, Field, Field]
+type Sampler = Callable[[float], Radiance]
+type Prepare = Callable[[ParticleGrid], Sampler]
+type EngineFactory = Callable[[ParticleGrid, Prepare], ParticleEngine]
+
+
+@dataclass(frozen=True)
+class ParticleGrid:
+    """Fixed square-pitch coordinates in row-major order, independent of display cells."""
+
+    width: int
+    height: int
+    x: Field
+    y: Field
+
+    @classmethod
+    def create(cls, width: int, height: int, *, span: tuple[float, float]) -> ParticleGrid:
+        if width < 1 or height < 1:
+            raise ValueError("a particle grid needs positive width and height")
+        pitch = max(span[0] / width, span[1] / height)
+        xs = (np.arange(width, dtype=np.float64) - (width - 1) / 2) * pitch
+        ys = (np.arange(height, dtype=np.float64) - (height - 1) / 2) * pitch
+        x, y = np.tile(xs, height), np.repeat(ys, width)
+        x.flags.writeable = y.flags.writeable = False
+        return cls(width, height, x, y)
+
+
+class ParticleEngine(Protocol):
+    """One owner, one size, explicit time, borrowed planar RGB output.
+
+    Each channel has width * height finite values in [0, 1]. Output is valid until
+    the next call and must not be mutated by consumers. Factories create independent
+    state. Engines receive explicit time and samplers, never widgets or concrete themes.
+    Raw samplers supply finite non-negative radiance, with no upper bound.
+    """
+
+    def frame(self, seconds: float, elapsed: float) -> Radiance: ...
+
+
+def buffer(size: int, value: float = 0.0) -> Field:
+    return np.full(size, value, dtype=np.float64)
+
+
+def clip(values: Field, low: float, high: float) -> None:
+    """Clamp in one native pass without cancellation at the bounds."""
+    np.clip(values, low, high, out=values)
+
+
+def band(values: Field, width: float) -> None:
+    """Replace signed distances with a Gaussian light band."""
+    np.divide(values, width, out=values)
+    np.square(values, out=values)
+    np.negative(values, out=values)
+    np.exp(values, out=values)
+
+
+class Spectrum:
+    """Reusable piecewise-linear RGB interpolation buffers for one sampler."""
+
+    def __init__(self, size: int, stops: tuple[tuple[float, float, float], ...]) -> None:
+        self.stops = stops
+        self.channels: Radiance = (buffer(size), buffer(size), buffer(size))
+        self._knots = np.linspace(0.0, 1.0, len(stops))
+        self._colors = np.asarray(stops).T.copy()
+
+    def sample(self, position: Field, light: Field) -> Radiance:
+        for channel, colors in zip(self.channels, self._colors, strict=True):
+            np.multiply(np.interp(position, self._knots, colors), light, out=channel)
+        return self.channels
+
+
+class PhosphorField:
+    """Size-owned buffers; no terminal encoding, UI objects or theme knowledge."""
+
+    def __init__(self, grid: ParticleGrid, prepare: Prepare) -> None:
+        self.grid = grid
+        self._sample = prepare(grid)
+        dots = grid.width * grid.height
+        self._emission: Radiance = (buffer(dots), buffer(dots), buffer(dots))
+        self._mapped: Radiance = (buffer(dots), buffer(dots), buffer(dots))
+        self._root = buffer(dots)
+
+    def _map_light(self, light: Field, emission: Field, mapped: Field, decay: float) -> None:
+        np.multiply(emission, decay, out=emission)
+        np.maximum(light, emission, out=emission)
+        shape = (self.grid.height, self.grid.width)
+        source, target = emission.reshape(shape), mapped.reshape(shape)
+        # A four-neighbour stencil on views: no padding copies or row wraparound.
+        target.fill(0.0)
+        target[1:] += source[:-1]
+        target[:-1] += source[1:]
+        target[:, 1:] += source[:, :-1]
+        target[:, :-1] += source[:, 1:]
+        np.multiply(mapped, 0.075, out=mapped)
+        np.add(mapped, emission, out=mapped)
+        np.multiply(mapped, -1.5, out=mapped)
+        np.expm1(mapped, out=mapped)
+        np.negative(mapped, out=mapped)
+        # x**(3/4) uses two hardware square roots instead of a general power.
+        # Multiplying the roots last also preserves subnormal input light.
+        np.sqrt(mapped, out=self._root)
+        np.sqrt(self._root, out=mapped)
+        np.multiply(mapped, self._root, out=mapped)
+
+    def frame(self, seconds: float, elapsed: float) -> Radiance:
+        decay = exp(-max(0, elapsed) / 0.085)
+        # Numerical faults still reach the owning worker. Underflow is normal in
+        # Gaussian tails; do not alter the application's global NumPy policy.
+        with np.errstate(over="raise", invalid="raise", divide="raise", under="ignore"):
+            for light, emission, mapped in zip(
+                self._sample(seconds), self._emission, self._mapped, strict=True
+            ):
+                self._map_light(light, emission, mapped, decay)
+        return self._mapped

ouro_tui_themes-0.3.6/src/ouro_tui_themes/dot_matrix/raster.py

@@ -0,0 +1,169 @@
+"""Adapt a numerical particle engine to Braille cells and damaged terminal rows."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from functools import lru_cache
+
+import numpy as np
+from rich.color import Color
+from rich.segment import Segment
+from rich.style import Style
+from textual.geometry import Region
+from textual.strip import Strip
+
+from ouro_tui_themes.dot_matrix.field import (
+    EngineFactory,
+    Field,
+    ParticleGrid,
+    PhosphorField,
+    Prepare,
+)
+
+_BRAILLE_BITS = (1, 8, 2, 16, 4, 32, 64, 128)
+_THRESHOLDS = (0.08, 0.48, 0.68, 0.28, 0.23, 0.63, 0.43, 0.13)
+_COLOR_THRESHOLDS = tuple(value * 0.25 for value in _THRESHOLDS)
+_GLYPHS = (" ",) + tuple(chr(0x2800 + mask) for mask in range(1, 256))
+
+
+@dataclass(frozen=True)
+class DotArtwork:
+    """Theme sampler, sampling span and replaceable numerical backend."""
+
+    prepare: Prepare
+    span: tuple[float, float]
+    engine_factory: EngineFactory = PhosphorField
+
+
+class FrameStrip(Strip):
+    """Transient rows without self-referential no-op division caches.
+
+    Textual's full-width divide caches [self], retaining dynamic rows until cyclic
+    GC. A no-op needs no cache; real divisions retain Textual's implementation.
+    """
+
+    __slots__ = ("__weakref__",)
+
+    def divide(self, cuts: Iterable[int]) -> Sequence[Strip]:
+        cuts = tuple(cut for cut in cuts if cut <= self.cell_length)
+        if cuts == (self.cell_length,):
+            return (self,)
+        return super().divide(cuts)
+
+
+@lru_cache(maxsize=4096)
+def _led_style(rgb: int | None) -> Style:
+    return (
+        Style()
+        if rgb is None
+        else Style(color=Color.from_rgb(rgb >> 16, (rgb >> 8) & 255, rgb & 255))
+    )
+
+
+class PhosphorRaster:
+    """One numerical engine and reusable terminal encoding buffers per size."""
+
+    def __init__(self, style: DotArtwork, columns: int, rows: int) -> None:
+        self.columns, self.rows = columns, rows
+        grid = ParticleGrid.create(columns * 2, rows * 4, span=style.span)
+        self._engine = style.engine_factory(grid, style.prepare)
+        self._luminance = np.empty(grid.width * grid.height, dtype=np.float64)
+        self._lanes = self._dot_views(self._luminance)
+        shape = (rows, columns)
+        self._peak = np.empty(shape, dtype=np.float64)
+        self._color = np.empty(shape, dtype=np.float64)
+        self._above = np.empty(shape, dtype=np.bool_)
+        self._visible = np.empty(shape, dtype=np.bool_)
+        self._masks = np.empty(shape, dtype=np.uint32)
+        self._channel = np.empty(shape, dtype=np.uint32)
+        self._packed = np.empty(shape, dtype=np.uint32)
+        self._cells = np.zeros(shape, dtype=np.uint32)
+        self._changed = np.empty(shape, dtype=np.bool_)
+        self._lines: tuple[Strip, ...] = ()
+        self.damage: tuple[Region, ...] = ()
+
+    def invalidate_frame(self) -> None:
+        """Require a full repaint while retaining the size-owned numerical engine."""
+        self._lines = ()
+        self.damage = ()
+
+    def _dot_views(self, field: Field) -> tuple[Field, ...]:
+        """Eight strided views of row-major dots; no dot-to-cell transpose/copy."""
+        blocks = np.asarray(field).reshape(self.rows, 4, self.columns, 2)
+        return tuple(blocks[:, dy, :, dx] for dy in range(4) for dx in range(2))
+
+    def frame(
+        self,
+        seconds: float,
+        elapsed: float,
+        *,
+        monochrome: bool = False,
+        background: tuple[int, int, int] = (0, 0, 0),
+    ) -> tuple[Strip, ...]:
+        mapped_channels = self._engine.frame(seconds, elapsed)
+        np.maximum(mapped_channels[0], mapped_channels[1], out=self._luminance)
+        np.maximum(self._luminance, mapped_channels[2], out=self._luminance)
+        self._peak[:] = self._lanes[0]
+        for lane in self._lanes[1:]:
+            np.maximum(self._peak, lane, out=self._peak)
+        if not monochrome:
+            self._peak *= 0.30
+        self._masks.fill(0)
+        thresholds = _THRESHOLDS if monochrome else _COLOR_THRESHOLDS
+        for lane, bit, threshold in zip(self._lanes, _BRAILLE_BITS, thresholds, strict=True):
+            np.greater(lane, threshold, out=self._above)
+            if not monochrome:
+                np.greater_equal(lane, self._peak, out=self._visible)
+                self._above &= self._visible
+            # Fade by coverage as well as color. Dark foregrounds may be raised
+            # by terminals, but absent dots cannot be brightened.
+            np.bitwise_or(self._masks, bit, out=self._masks, where=self._above)
+        self._packed[:] = self._masks
+        for mapped, base, shift in zip(mapped_channels, background, (24, 16, 8), strict=True):
+            lanes = self._dot_views(mapped)
+            self._color[:] = lanes[0]
+            for lane in lanes[1:]:
+                self._color += lane
+            self._color *= 1.25 / 8
+            np.clip(self._color, 0.0, 1.0, out=self._color)
+            # Screen-compose emitted light over the actual canvas. Zero light
+            # leaves the background unchanged, including in individual channels.
+            self._color *= 255 - base
+            self._color += base
+            np.copyto(self._channel, self._color, casting="unsafe")
+            np.left_shift(self._channel, shift, out=self._channel)
+            self._packed |= self._channel
+        np.equal(self._masks, 0, out=self._above)
+        np.copyto(self._packed, 0, where=self._above)
+        np.not_equal(self._packed, self._cells, out=self._changed)
+        if not self._lines:
+            self._changed.fill(True)
+        changed_rows = np.flatnonzero(self._changed.any(axis=1))
+        if not len(changed_rows):
+            self.damage = ()
+            return self._lines
+        self._cells[:] = self._packed
+        rows = list(self._lines) if self._lines else [Strip.blank(self.columns)] * self.rows
+        damage = []
+        for row in changed_rows.tolist():
+            changed = np.flatnonzero(self._changed[row])
+            first, last = int(changed[0]), int(changed[-1])
+            segments: list[Segment] = []
+            run: list[str] = []
+            previous: int | None = None
+            # Cross the Python/Rich boundary only for rows with changed final cells.
+            for cell in self._packed[row].tolist():
+                key = cell >> 8 if cell else None
+                if run and key != previous:
+                    segments.append(Segment("".join(run), _led_style(previous)))
+                    run.clear()
+                run.append(_GLYPHS[cell & 255])
+                previous = key
+            if run:
+                segments.append(Segment("".join(run), _led_style(previous)))
+            rows[row] = Strip(segments, self.columns)
+            damage.append(Region(first, row, last - first + 1, 1))
+        self._lines = tuple(rows)
+        self.damage = tuple(damage)
+        return self._lines

ouro_tui_themes-0.3.6/src/ouro_tui_themes/dot_matrix/requirements.py

@@ -0,0 +1,29 @@
+"""Availability of the optional numerical backend; no renderer imports."""
+
+from importlib import import_module
+from importlib.metadata import PackageNotFoundError, version
+
+from packaging.specifiers import SpecifierSet
+from packaging.version import InvalidVersion
+
+_NUMPY_VERSIONS = SpecifierSet(">=2.3.3,<3")
+_INSTALL_HINT = "Install ouro-agent[themes] in the OURO environment and restart the TUI."
+
+
+def check_requirements() -> str | None:
+    """Check the actual extension, not just the presence of package metadata."""
+    try:
+        installed = version("numpy")
+    except PackageNotFoundError:
+        return f"numpy is not installed. {_INSTALL_HINT}"
+    try:
+        compatible = installed in _NUMPY_VERSIONS
+    except InvalidVersion:
+        compatible = False
+    if not compatible:
+        return f"numpy {installed} is incompatible; requires {_NUMPY_VERSIONS}. {_INSTALL_HINT}"
+    try:
+        import_module("numpy")
+    except (ImportError, OSError) as exc:
+        return f"numpy could not load: {exc}. {_INSTALL_HINT}"
+    return None

ouro_tui_themes-0.3.6/src/ouro_tui_themes/dot_matrix/widget.py

@@ -0,0 +1,187 @@
+"""Textual presentation and lifecycle for the selected welcome artwork."""
+
+from __future__ import annotations
+
+import asyncio
+from time import monotonic
+
+from textual import events
+from textual.geometry import Region, Size
+from textual.strip import Strip
+from textual.widget import Widget
+from textual.worker import Worker
+
+from ouro_tui_themes.dot_matrix.raster import DotArtwork, FrameStrip, PhosphorRaster
+
+
+def _render_frame(
+    artwork: DotArtwork,
+    raster: PhosphorRaster | None,
+    size: Size,
+    seconds: float,
+    delta: float,
+    monochrome: bool,
+    background: tuple[int, int, int],
+) -> tuple[PhosphorRaster, tuple[Strip, ...], tuple[Region, ...]]:
+    """Compute with exclusive raster ownership and no access to mounted widgets."""
+    if raster is None or (raster.columns, raster.rows) != (size.width, size.height):
+        raster = PhosphorRaster(artwork, size.width, size.height)
+    lines = raster.frame(seconds, delta, monochrome=monochrome, background=background)
+    return raster, lines, raster.damage
+
+
+class DotMatrix(Widget):
+    """Sample off-loop at up to 30 Hz, publishing only the current viewport."""
+
+    DEFAULT_CSS = """
+    DotMatrix { width: 100%; height: 1fr; min-height: 0; overflow: hidden; }
+    """
+
+    def __init__(self, style: DotArtwork) -> None:
+        super().__init__()
+        self.artwork = style
+        self.active = False
+        self.elapsed = 0.0
+        self._last_tick: float | None = None
+        self._frame_requested = asyncio.Event()
+        self._raster: PhosphorRaster | None = None
+        self._lines: tuple[Strip, ...] = ()
+        self._rendering = False
+        self._render_revision = 0
+        self._pending_frame: tuple[Size, float, float, bool, tuple[int, int, int]] | None = None
+
+    def on_mount(self) -> None:
+        _worker: Worker[None] = self.run_worker(self._render_frames, group="welcome-artwork")
+        self._paint(0)
+
+    def on_unmount(self) -> None:
+        self._render_revision += 1
+        self._pending_frame = None
+        self._frame_requested.set()
+        self._raster = None
+        self._lines = ()
+
+    def set_active(self, active: bool) -> None:
+        if active == self.active:
+            return
+        self.active = active
+        self._render_revision += 1
+        self._last_tick = None
+        self._pending_frame = None
+        self._frame_requested.set()
+        if self.is_mounted and (
+            active
+            or self._raster is None
+            or (self._raster.columns, self._raster.rows) != (self.size.width, self.size.height)
+        ):
+            self._paint(0)
+
+    def _tick(self) -> None:
+        now = monotonic()
+        delta = 0.0 if self._last_tick is None else now - self._last_tick
+        self._last_tick = now
+        self.elapsed += delta
+        self._paint(delta)
+
+    def on_resize(self, event: events.Resize) -> None:
+        # A new size needs a frame even when animation playback is paused.
+        self._paint(0)
+
+    def refresh_theme(self) -> None:
+        if self.is_mounted:
+            self._paint(0)
+
+    def _paint(self, delta: float) -> None:
+        self._render_revision += 1
+        self._pending_frame = None
+        size = self.size
+        columns, rows = size
+        if columns < 1 or rows < 1:
+            return
+        self._pending_frame = (
+            size,
+            self.elapsed,
+            delta,
+            self.app.no_color,
+            self.background_colors[1].rgb,
+        )
+        self._frame_requested.set()
+
+    async def _render_frames(self) -> None:
+        """One lifetime-owned worker; no frame queue or per-frame Textual workers.
+
+        Deadlines are measured from the start of computation. Slow frames yield
+        before continuing at current playback time, without waiting an extra tick
+        or replaying missed frames. Geometry and static repaint requests wake the
+        same loop, including when playback is paused.
+        """
+        deadline = 0.0
+        try:
+            # A worker can start before the Mount handler has completed.
+            # Textual cancels this owned worker when the widget is removed.
+            while True:
+                if self._pending_frame is None:
+                    if self.active and self.size.area:
+                        delay = max(0.0, deadline - monotonic())
+                        if delay:
+                            try:
+                                await asyncio.wait_for(self._frame_requested.wait(), delay)
+                            except TimeoutError:
+                                pass
+                        else:
+                            await asyncio.sleep(0)
+                        if self._pending_frame is None and self.active:
+                            self._tick()
+                    else:
+                        await self._frame_requested.wait()
+                self._frame_requested.clear()
+                if self._pending_frame is None:
+                    continue
+                revision = self._render_revision
+                size, seconds, delta, monochrome, background = self._pending_frame
+                self._pending_frame = None
+                self._rendering = True
+                started = monotonic()
+                # Keep cadence through timer jitter, but do not queue missed frames.
+                deadline = (deadline if 0 <= started - deadline < 1 / 30 else started) + 1 / 30
+                raster, lines, damage = await asyncio.to_thread(
+                    _render_frame,
+                    self.artwork,
+                    self._raster,
+                    size,
+                    seconds,
+                    delta,
+                    monochrome,
+                    background,
+                )
+                self._rendering = False
+                if not self.is_mounted:
+                    continue
+                if size != self.size:
+                    self._raster = None
+                    continue
+                self._raster = raster
+                if revision != self._render_revision:
+                    # Numerical state belongs to this size; the terminal baseline
+                    # is valid only for frames that were actually published.
+                    raster.invalidate_frame()
+                    continue
+                self._lines = lines
+                if damage:
+                    self.refresh(*damage)
+        finally:
+            self._rendering = False
+
+    def render_line(self, y: int) -> Strip:
+        if y < len(self._lines):
+            return (
+                self._lines[y]
+                .apply_style(self.rich_style)
+                .adjust_cell_length(self.size.width, self.rich_style)
+            )
+        return Strip.blank(self.size.width, self.rich_style)
+
+    def render_lines(self, crop: Region) -> list[Strip]:
+        # Preserve Textual CSS, opacity, filters and cropping before transferring
+        # disposable frame rows to the compositor.
+        return [FrameStrip(line, line.cell_length) for line in super().render_lines(crop)]

ouro_tui_themes-0.3.6/src/ouro_tui_themes/styles/__init__.py

@@ -0,0 +1,41 @@
+"""Bundled theme metadata and lazy loading of each theme-owned page."""
+
+from functools import partial
+from importlib import import_module
+from typing import cast
+
+from ouro.tui.welcome.model import WelcomePage, WelcomeStyle
+from ouro_tui_themes.dot_matrix.requirements import check_requirements
+
+
+def _create_page(module: str) -> WelcomePage:
+    # Only the selected theme loads its page and optional computation dependencies.
+    theme = import_module(f"ouro_tui_themes.styles.{module}")
+    return cast(WelcomePage, theme.create_page())
+
+
+def _particle_style(module: str, style_id: str, label: str, description: str) -> WelcomeStyle:
+    return WelcomeStyle(
+        style_id,
+        label,
+        description,
+        partial(_create_page, module),
+        check_requirements=check_requirements,
+    )
+
+
+STYLES = (
+    _particle_style(
+        "event_horizon", "event-horizon", "Horizon", "An ember disk folded around a dark sun."
+    ),
+    _particle_style(
+        "electron_bloom", "electron-bloom", "Bloom", "Ice and copper petals exchanging light."
+    ),
+    _particle_style(
+        "interference", "interference", "Tide", "Jade light woven into a breathing caustic."
+    ),
+    _particle_style("clifford", "clifford-torus", "Iris", "An iris of folded ultraviolet light."),
+    _particle_style(
+        "crystal", "quasicrystal", "Prism", "An aperiodic rose cut from copper and light."
+    ),
+)

ouro_tui_themes-0.3.6/src/ouro_tui_themes/styles/clifford.py

@@ -0,0 +1,133 @@
+"""A Clifford torus rotated in four dimensions, sampled by inverse projection."""
+
+from math import cos, exp, sin
+
+import numpy as np
+from rich.text import Text
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from ouro.tui.welcome.centered import CenteredWelcomePage
+from ouro_tui_themes.dot_matrix.field import (
+    ParticleGrid,
+    Radiance,
+    Sampler,
+    Spectrum,
+    band,
+    buffer,
+)
+from ouro_tui_themes.dot_matrix.raster import DotArtwork
+from ouro_tui_themes.dot_matrix.widget import DotMatrix
+
+_SPECTRUM = ((0.21, 0.12, 0.58), (0.51, 0.34, 1.0), (0.38, 0.86, 1.0), (0.92, 0.98, 1.0))
+_DEPTHS = tuple(-2.2 + index * (4.4 / 13) for index in range(13)) + (2.2,)
+
+
+def prepare(grid: ParticleGrid) -> Sampler:
+    x, y = grid.x.copy(), grid.y.copy()
+    np.multiply(x, 2.5, out=x)
+    np.multiply(y, 2.5, out=y)
+    (
+        radial,
+        angle,
+        rotated_x,
+        rotated_y,
+        rx,
+        ry,
+        work,
+        surface,
+        weave,
+        density,
+        light,
+        transmission,
+        position,
+        falloff,
+    ) = (buffer(len(x)) for _ in range(14))
+    np.multiply(x, x, out=radial)
+    np.multiply(y, y, out=work)
+    np.add(radial, work, out=radial)
+    np.arctan2(y, x, out=angle)
+    np.multiply(radial, -0.32, out=falloff)
+    np.exp(falloff, out=falloff)
+    # The inverse stereographic denominator depends only on the fixed grid/depth.
+    # Keep one reciprocal plane per ray sample, not four projected coordinates.
+    depths = tuple(
+        (depth, exp(-depth * depth * 0.32) * 0.65, 1.0 / (radial + depth * depth + 1.0))
+        for depth in _DEPTHS
+    )
+    spectrum = Spectrum(len(x), _SPECTRUM)
+
+    def sample(seconds: float) -> Radiance:
+        a = 0.18 * sin(seconds * 0.19)
+        b = 0.55 + 0.35 * sin(seconds * 0.13)
+        ca, sa, cb, sb = cos(a), sin(a), cos(b), sin(b)
+        light.fill(0.0)
+        transmission.fill(1.0)
+        np.multiply(x, 2.0 * ca, out=rotated_x)
+        np.add(rotated_x, 2.0 * sa, out=rotated_x)
+        np.multiply(y, 2.0 * cb, out=rotated_y)
+        # Integrate fixed view rays through S3; rotate the projected surface,
+        # never the receiving LED grid.
+        for depth, attenuation, reciprocal in depths:
+            np.multiply(rotated_x, reciprocal, out=rx)
+            np.subtract(rx, sa, out=rx)
+            np.subtract(rotated_y, 2 * depth * sb, out=ry)
+            np.multiply(ry, reciprocal, out=ry)
+            np.multiply(rx, rx, out=surface)
+            np.multiply(ry, ry, out=work)
+            np.add(surface, work, out=surface)
+            np.subtract(surface, 0.5, out=surface)
+            np.add(rx, ry, out=weave)
+            np.multiply(weave, 28.0, out=weave)
+            np.subtract(weave, seconds * 0.5, out=weave)
+            np.cos(weave, out=weave)
+            np.multiply(weave, weave, out=weave)
+            np.multiply(weave, 0.35, out=weave)
+            np.add(weave, 0.65, out=weave)
+            density[:] = surface
+            band(density, 0.07)
+            np.multiply(density, falloff, out=density)
+            np.multiply(density, attenuation, out=density)
+            np.multiply(density, weave, out=work)
+            np.multiply(work, transmission, out=work)
+            np.multiply(work, 1 - depth * 0.18, out=work)
+            np.add(light, work, out=light)
+            np.multiply(density, 0.55, out=work)
+            np.subtract(1.0, work, out=work)
+            np.multiply(transmission, work, out=transmission)
+        np.add(angle, seconds * 0.17, out=position)
+        np.sin(position, out=position)
+        np.multiply(position, 0.5, out=position)
+        np.add(position, 0.5, out=position)
+        np.multiply(light, 1.8, out=light)
+        return spectrum.sample(position, light)
+
+    return sample
+
+
+class IrisPage(CenteredWelcomePage):
+    DEFAULT_CSS = """
+    IrisPage .phosphor-art {
+        layout: vertical; width: 100%; height: 1fr; min-height: 0; margin-bottom: 1;
+    }
+    IrisPage .art-caption { width: 100%; height: 1; text-align: center; }
+    """
+
+    def __init__(self) -> None:
+        self.artwork = DotArtwork(prepare, span=(5.8, 2.7))
+        self.matrix = DotMatrix(self.artwork)
+        self._caption = Static(classes="art-caption")
+        super().__init__(Vertical(self.matrix, self._caption, classes="phosphor-art"))
+
+    def set_active(self, active: bool) -> None:
+        self.matrix.set_active(active)
+
+    def refresh_theme(self) -> None:
+        theme = self.tui_theme
+        caption = Text("O U R O", style=theme.text_emphasis)
+        caption.append("  /  IRIS", style=theme.text_lowlight)
+        self._caption.update(caption)
+
+
+def create_page() -> IrisPage:
+    return IrisPage()

ouro_tui_themes-0.3.6/src/ouro_tui_themes/styles/crystal.py

@@ -0,0 +1,103 @@
+"""Five reciprocal-lattice waves reveal a nonperiodic diffraction rosette."""
+
+from math import cos, pi, sin
+
+import numpy as np
+from rich.text import Text
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from ouro.tui.welcome.centered import CenteredWelcomePage
+from ouro_tui_themes.dot_matrix.field import (
+    ParticleGrid,
+    Radiance,
+    Sampler,
+    Spectrum,
+    band,
+    buffer,
+    clip,
+)
+from ouro_tui_themes.dot_matrix.raster import DotArtwork
+from ouro_tui_themes.dot_matrix.widget import DotMatrix
+
+_SPECTRUM = ((0.29, 0.05, 0.09), (0.86, 0.21, 0.19), (1.0, 0.64, 0.39), (1.0, 0.97, 0.82))
+
+
+def prepare(grid: ParticleGrid) -> Sampler:
+    x, y = grid.x, grid.y
+    work, aperture = buffer(len(x)), buffer(len(x))
+    projections = []
+    for index in range(5):
+        angle = index * pi / 5
+        projection = buffer(len(x))
+        np.multiply(x, cos(angle), out=projection)
+        np.multiply(y, sin(angle), out=work)
+        np.add(projection, work, out=projection)
+        np.multiply(projection, 15.0, out=projection)
+        projections.append((np.cos(projection), np.sin(projection)))
+    np.hypot(x, y, out=aperture)
+    np.divide(aperture, 1.05, out=aperture)
+    np.power(aperture, 8.0, out=aperture)
+    np.negative(aperture, out=aperture)
+    np.exp(aperture, out=aperture)
+    wave, quadrature, light, position = (buffer(len(x)) for _ in range(4))
+    spectrum = Spectrum(len(x), _SPECTRUM)
+
+    def sample(seconds: float) -> Radiance:
+        wave.fill(0.0)
+        quadrature.fill(0.0)
+        for index, (spatial_cos, spatial_sin) in enumerate(projections):
+            phase = sin(seconds * 0.17 + index * 2.4) * 1.6
+            cp, sp = cos(phase), sin(phase)
+            np.multiply(spatial_cos, cp, out=work)
+            np.add(wave, work, out=wave)
+            np.multiply(spatial_sin, sp, out=work)
+            np.subtract(wave, work, out=wave)
+            np.multiply(spatial_sin, cp, out=work)
+            np.add(quadrature, work, out=quadrature)
+            np.multiply(spatial_cos, sp, out=work)
+            np.subtract(quadrature, work, out=quadrature)
+        np.absolute(wave, out=wave)
+        np.subtract(wave, 0.6, out=light)
+        np.divide(light, 4.4, out=light)
+        clip(light, 0.0, 1.0)
+        np.power(light, 1.35, out=light)
+        np.multiply(light, 1.7, out=light)
+        band(quadrature, 0.35)
+        np.multiply(quadrature, 0.3, out=quadrature)
+        np.add(light, quadrature, out=light)
+        np.multiply(light, aperture, out=light)
+        np.multiply(light, 1.8, out=light)
+        np.multiply(wave, 0.12, out=position)
+        np.add(position, 0.4, out=position)
+        return spectrum.sample(position, light)
+
+    return sample
+
+
+class PrismPage(CenteredWelcomePage):
+    DEFAULT_CSS = """
+    PrismPage .phosphor-art {
+        layout: vertical; width: 100%; height: 1fr; min-height: 0; margin-bottom: 1;
+    }
+    PrismPage .art-caption { width: 100%; height: 1; text-align: center; }
+    """
+
+    def __init__(self) -> None:
+        self.artwork = DotArtwork(prepare, span=(5.8, 2.7))
+        self.matrix = DotMatrix(self.artwork)
+        self._caption = Static(classes="art-caption")
+        super().__init__(Vertical(self.matrix, self._caption, classes="phosphor-art"))
+
+    def set_active(self, active: bool) -> None:
+        self.matrix.set_active(active)
+
+    def refresh_theme(self) -> None:
+        theme = self.tui_theme
+        caption = Text("O U R O", style=theme.text_emphasis)
+        caption.append("  /  PRISM", style=theme.text_lowlight)
+        self._caption.update(caption)
+
+
+def create_page() -> PrismPage:
+    return PrismPage()

ouro_tui_themes-0.3.6/src/ouro_tui_themes/styles/electron_bloom.py

@@ -0,0 +1,104 @@
+"""Phase beating between angular orbital modes and their radial nodes."""
+
+from math import cos, sin
+
+import numpy as np
+from rich.text import Text
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from ouro.tui.welcome.centered import CenteredWelcomePage
+from ouro_tui_themes.dot_matrix.field import (
+    ParticleGrid,
+    Radiance,
+    Sampler,
+    Spectrum,
+    band,
+    buffer,
+)
+from ouro_tui_themes.dot_matrix.raster import DotArtwork
+from ouro_tui_themes.dot_matrix.widget import DotMatrix
+
+_SPECTRUM = ((0.11, 0.49, 0.83), (0.62, 0.91, 1.0), (1.0, 0.92, 0.72), (1.0, 0.37, 0.08))
+
+
+def prepare(grid: ParticleGrid) -> Sampler:
+    x, y = grid.x, grid.y
+    radius, angle, radial, overtone, envelope, nucleus = (buffer(len(x)) for _ in range(6))
+    np.hypot(x, y, out=radius)
+    np.arctan2(y, x, out=angle)
+    np.multiply(radius, 3.6, out=radial)
+    np.subtract(radial, 0.4, out=radial)
+    np.sin(radial, out=radial)
+    np.multiply(radius, 5.3, out=overtone)
+    np.sin(overtone, out=overtone)
+    np.multiply(overtone, 0.32, out=overtone)
+    np.divide(radius, 1.02, out=envelope)
+    np.power(envelope, 4.0, out=envelope)
+    np.negative(envelope, out=envelope)
+    np.exp(envelope, out=envelope)
+    nucleus[:] = radius
+    band(nucleus, 0.105)
+    np.multiply(nucleus, 0.65, out=nucleus)
+    # Separate the fixed angular modes from their scalar time phases exactly.
+    radial_cos = np.cos(angle * 3.0) * radial
+    radial_sin = np.sin(angle * 3.0) * radial
+    overtone_sin = np.sin(angle * 2.0) * overtone
+    overtone_cos = np.cos(angle * 2.0) * overtone
+    amplitude, work, light, position = (buffer(len(x)) for _ in range(4))
+    spectrum = Spectrum(len(x), _SPECTRUM)
+
+    def sample(seconds: float) -> Radiance:
+        phase = seconds * 0.24
+        np.multiply(radial_cos, cos(phase), out=amplitude)
+        np.multiply(radial_sin, sin(phase), out=work)
+        np.subtract(amplitude, work, out=amplitude)
+        np.multiply(overtone_sin, cos(phase * 0.7), out=work)
+        np.add(amplitude, work, out=amplitude)
+        np.multiply(overtone_cos, sin(phase * 0.7), out=work)
+        np.subtract(amplitude, work, out=amplitude)
+        np.multiply(amplitude, amplitude, out=light)
+        np.multiply(light, envelope, out=light)
+        np.multiply(light, 1.65, out=light)
+        np.absolute(amplitude, out=work)
+        np.subtract(work, 0.65, out=work)
+        band(work, 0.06)
+        np.multiply(work, envelope, out=work)
+        np.multiply(work, 0.25, out=work)
+        np.add(light, work, out=light)
+        np.add(light, nucleus, out=light)
+        np.multiply(amplitude, 2.4, out=position)
+        np.tanh(position, out=position)
+        np.multiply(position, 0.5, out=position)
+        np.add(position, 0.5, out=position)
+        return spectrum.sample(position, light)
+
+    return sample
+
+
+class BloomPage(CenteredWelcomePage):
+    DEFAULT_CSS = """
+    BloomPage .phosphor-art {
+        layout: vertical; width: 100%; height: 1fr; min-height: 0; margin-bottom: 1;
+    }
+    BloomPage .art-caption { width: 100%; height: 1; text-align: center; }
+    """
+
+    def __init__(self) -> None:
+        self.artwork = DotArtwork(prepare, span=(5.8, 2.7))
+        self.matrix = DotMatrix(self.artwork)
+        self._caption = Static(classes="art-caption")
+        super().__init__(Vertical(self.matrix, self._caption, classes="phosphor-art"))
+
+    def set_active(self, active: bool) -> None:
+        self.matrix.set_active(active)
+
+    def refresh_theme(self) -> None:
+        theme = self.tui_theme
+        caption = Text("O U R O", style=theme.text_emphasis)
+        caption.append("  /  BLOOM", style=theme.text_lowlight)
+        self._caption.update(caption)
+
+
+def create_page() -> BloomPage:
+    return BloomPage()

ouro_tui_themes-0.3.6/src/ouro_tui_themes/styles/event_horizon.py

@@ -0,0 +1,122 @@
+"""An occulted accretion disk and its bent upper and lower light paths."""
+
+from math import sin
+
+import numpy as np
+from rich.text import Text
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from ouro.tui.welcome.centered import CenteredWelcomePage
+from ouro_tui_themes.dot_matrix.field import (
+    ParticleGrid,
+    Radiance,
+    Sampler,
+    Spectrum,
+    band,
+    buffer,
+    clip,
+)
+from ouro_tui_themes.dot_matrix.raster import DotArtwork
+from ouro_tui_themes.dot_matrix.widget import DotMatrix
+
+_SPECTRUM = ((0.30, 0.045, 0.008), (1.0, 0.27, 0.045), (1.0, 0.78, 0.38), (1.0, 0.98, 0.86))
+
+
+def prepare(grid: ParticleGrid) -> Sampler:
+    x, y = grid.x, grid.y
+    (tilted, radius, angle, disk_radius, turbulence, work, disk, light, position, beaming) = (
+        buffer(len(x)) for _ in range(10)
+    )
+    np.divide(x, -1.6, out=beaming)
+    clip(beaming, -0.7, 1.0)
+    np.multiply(beaming, 0.48, out=beaming)
+    np.add(beaming, 0.65, out=beaming)
+    spectrum = Spectrum(len(x), _SPECTRUM)
+
+    def sample(seconds: float) -> Radiance:
+        tilt = 0.10 + 0.055 * sin(seconds * 0.13)
+        np.multiply(x, tilt, out=tilted)
+        np.subtract(y, tilted, out=tilted)
+        np.hypot(x, tilted, out=radius)
+        np.arctan2(tilted, x, out=angle)
+        np.divide(tilted, 0.24, out=work)
+        np.hypot(x, work, out=disk_radius)
+        np.multiply(disk_radius, 21.0, out=turbulence)
+        np.subtract(turbulence, seconds * 1.7, out=turbulence)
+        np.multiply(angle, 3.0, out=work)
+        np.add(turbulence, work, out=turbulence)
+        np.sin(turbulence, out=turbulence)
+        np.multiply(turbulence, 0.16, out=turbulence)
+        np.add(turbulence, 0.76, out=turbulence)
+        np.multiply(disk_radius, 43.0, out=work)
+        np.multiply(angle, 7.0, out=disk)
+        np.add(work, disk, out=work)
+        np.add(work, seconds * 0.8, out=work)
+        np.sin(work, out=work)
+        np.multiply(work, 0.08, out=work)
+        np.add(turbulence, work, out=turbulence)
+        np.subtract(disk_radius, 1.13, out=disk)
+        band(disk, 0.62)
+        np.multiply(disk, turbulence, out=disk)
+        np.multiply(disk, beaming, out=light)
+        # The far-side disk is seen over the shadow; the near side hides its base.
+        np.add(angle, 1.1, out=work)
+        np.cos(work, out=work)
+        np.multiply(work, 0.36, out=work)
+        np.add(work, 0.64, out=work)
+        np.subtract(radius, 0.64, out=disk)
+        band(disk, 0.085)
+        np.multiply(disk, work, out=disk)
+        np.add(light, disk, out=light)
+        np.subtract(radius, 0.70, out=work)
+        band(work, 0.20)
+        np.multiply(work, 0.17, out=work)
+        np.add(light, work, out=light)
+        np.subtract(radius, 0.535, out=work)
+        band(work, 0.018)
+        np.multiply(work, 0.9, out=work)
+        np.add(light, work, out=light)
+        np.subtract(radius, 0.49, out=work)
+        np.multiply(work, 55.0, out=work)
+        clip(work, 0.0, 1.0)
+        np.multiply(light, work, out=light)
+        np.subtract(radius, 1.9, out=work)
+        np.absolute(work, out=disk)
+        np.add(work, disk, out=work)
+        np.multiply(work, -1.5, out=work)
+        np.exp(work, out=work)
+        np.multiply(light, work, out=light)
+        np.multiply(light, 1.15, out=position)
+        np.multiply(light, 1.65, out=light)
+        return spectrum.sample(position, light)
+
+    return sample
+
+
+class HorizonPage(CenteredWelcomePage):
+    DEFAULT_CSS = """
+    HorizonPage .phosphor-art {
+        layout: vertical; width: 100%; height: 1fr; min-height: 0; margin-bottom: 1;
+    }
+    HorizonPage .art-caption { width: 100%; height: 1; text-align: center; }
+    """
+
+    def __init__(self) -> None:
+        self.artwork = DotArtwork(prepare, span=(5.8, 2.7))
+        self.matrix = DotMatrix(self.artwork)
+        self._caption = Static(classes="art-caption")
+        super().__init__(Vertical(self.matrix, self._caption, classes="phosphor-art"))
+
+    def set_active(self, active: bool) -> None:
+        self.matrix.set_active(active)
+
+    def refresh_theme(self) -> None:
+        theme = self.tui_theme
+        caption = Text("O U R O", style=theme.text_emphasis)
+        caption.append("  /  HORIZON", style=theme.text_lowlight)
+        self._caption.update(caption)
+
+
+def create_page() -> HorizonPage:
+    return HorizonPage()

ouro_tui_themes-0.3.6/src/ouro_tui_themes/styles/interference.py

@@ -0,0 +1,100 @@
+"""A caustic aperture formed by coherent sources and a slowly drifting phase."""
+
+from math import cos, sin
+
+import numpy as np
+from rich.text import Text
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from ouro.tui.welcome.centered import CenteredWelcomePage
+from ouro_tui_themes.dot_matrix.field import (
+    ParticleGrid,
+    Radiance,
+    Sampler,
+    Spectrum,
+    band,
+    buffer,
+)
+from ouro_tui_themes.dot_matrix.raster import DotArtwork
+from ouro_tui_themes.dot_matrix.widget import DotMatrix
+
+_SPECTRUM = ((0.025, 0.19, 0.25), (0.07, 0.66, 0.63), (0.49, 0.95, 0.77), (0.95, 1.0, 0.86))
+
+
+def prepare(grid: ParticleGrid) -> Sampler:
+    x, y = grid.x, grid.y.copy()
+    left, right, lower, aperture, center = (buffer(len(x)) for _ in range(5))
+    np.add(x, 0.83, out=left)
+    np.hypot(left, y, out=left)
+    np.subtract(x, 0.83, out=right)
+    np.hypot(right, y, out=right)
+    np.subtract(y, 1.2, out=lower)
+    np.hypot(x, lower, out=lower)
+    np.subtract(left, right, out=center)
+    band(center, 0.05)
+    np.multiply(center, 0.1, out=center)
+    np.multiply(left, 18.0, out=left)
+    np.multiply(right, 18.0, out=right)
+    np.multiply(lower, 15.0, out=lower)
+    np.divide(x, 2.1, out=aperture)
+    np.power(aperture, 6.0, out=aperture)
+    np.divide(y, 0.9, out=y)
+    np.power(y, 6.0, out=y)
+    np.add(aperture, y, out=aperture)
+    np.negative(aperture, out=aperture)
+    np.exp(aperture, out=aperture)
+    # Both side sources share a time frequency, so sum their spatial bases once.
+    side_cos = np.cos(left) + np.cos(right)
+    side_sin = np.sin(left) - np.sin(right)
+    lower_cos, lower_sin = np.cos(lower) * 0.65, np.sin(lower) * 0.65
+    wave, work, position, light = (buffer(len(x)) for _ in range(4))
+    spectrum = Spectrum(len(x), _SPECTRUM)
+
+    def sample(seconds: float) -> Radiance:
+        phase = seconds * 0.55
+        np.multiply(side_cos, cos(phase), out=wave)
+        np.multiply(side_sin, sin(phase), out=work)
+        np.add(wave, work, out=wave)
+        np.multiply(lower_cos, cos(phase * 0.6), out=work)
+        np.add(wave, work, out=wave)
+        np.multiply(lower_sin, sin(phase * 0.6), out=work)
+        np.subtract(wave, work, out=wave)
+        np.absolute(wave, out=position)
+        np.divide(position, 2.65, out=position)
+        np.square(position, out=light)
+        np.multiply(light, position, out=light)
+        np.multiply(light, 1.7, out=light)
+        np.add(light, center, out=light)
+        np.multiply(light, aperture, out=light)
+        return spectrum.sample(position, light)
+
+    return sample
+
+
+class TidePage(CenteredWelcomePage):
+    DEFAULT_CSS = """
+    TidePage .phosphor-art {
+        layout: vertical; width: 100%; height: 1fr; min-height: 0; margin-bottom: 1;
+    }
+    TidePage .art-caption { width: 100%; height: 1; text-align: center; }
+    """
+
+    def __init__(self) -> None:
+        self.artwork = DotArtwork(prepare, span=(5.8, 2.7))
+        self.matrix = DotMatrix(self.artwork)
+        self._caption = Static(classes="art-caption")
+        super().__init__(Vertical(self.matrix, self._caption, classes="phosphor-art"))
+
+    def set_active(self, active: bool) -> None:
+        self.matrix.set_active(active)
+
+    def refresh_theme(self) -> None:
+        theme = self.tui_theme
+        caption = Text("O U R O", style=theme.text_emphasis)
+        caption.append("  /  TIDE", style=theme.text_lowlight)
+        self._caption.update(caption)
+
+
+def create_page() -> TidePage:
+    return TidePage()